Fix big character literal printing in External Core

[ghc-hetmet.git] / compiler / coreSyn / MkExternalCore.lhs

diff --git a/compiler/coreSyn/MkExternalCore.lhs b/compiler/coreSyn/MkExternalCore.lhs
index faa6bb9..3e8a989 100644 (file)
--- a/compiler/coreSyn/MkExternalCore.lhs
+++ b/compiler/coreSyn/MkExternalCore.lhs
@@ -25,12 +25,15 @@ import Name
 import NameSet
 import UniqSet
 import Outputable
+import Encoding
 import ForeignCall
 import DynFlags
 import StaticFlags
 import IO
 import FastString
 
+import Data.Char
+
 emitExternalCore :: DynFlags -> NameSet -> CgGuts -> IO ()
 emitExternalCore dflags exports cg_guts
  | opt_EmitExternalCore 
@@ -61,9 +64,23 @@ collect_tdefs tcon tdefs
   | isAlgTyCon tcon = tdef: tdefs
   where
     tdef | isNewTyCon tcon = 
-                C.Newtype (make_con_qid (tyConName tcon)) (map make_tbind tyvars) repclause 
+                C.Newtype (qtc tcon) (map make_tbind tyvars) 
+                  (case newTyConCo_maybe tcon of
+                     Just coercion -> (qtc coercion, 
+                       make_kind $ (uncurry mkCoKind) $  
+                                  case isCoercionTyCon_maybe coercion of
+                                    -- See Note [Newtype coercions] in 
+                                    -- types/TyCon
+                                    Just (arity,coKindFun) -> coKindFun $
+                                       map mkTyVarTy $ take arity tyvars
+                                    Nothing -> pprPanic ("MkExternalCore:\
+                                      coercion tcon should have a kind fun")
+                                        (ppr tcon))
+                     Nothing       -> pprPanic ("MkExternalCore: newtype tcon\
+                                       should have a coercion: ") (ppr tcon))
+                   repclause 
          | otherwise = 
-                C.Data (make_con_qid (tyConName tcon)) (map make_tbind tyvars) (map make_cdef (tyConDataCons tcon)) 
+                C.Data (qtc tcon) (map make_tbind tyvars) (map make_cdef (tyConDataCons tcon)) 
          where repclause | isRecursiveTyCon tcon || isOpenTyCon tcon= Nothing
                         | otherwise = Just (make_ty (repType rhs))
                                            where (_, rhs) = newTyConRhs tcon
@@ -71,6 +88,9 @@ collect_tdefs tcon tdefs
 
 collect_tdefs _ tdefs = tdefs
 
+qtc :: TyCon -> C.Qual C.Tcon
+qtc = make_con_qid . tyConName
+
 
 make_cdef :: DataCon -> C.Cdef
 make_cdef dcon =  C.Constr dcon_name existentials tys
@@ -142,7 +162,12 @@ make_alt a@(DEFAULT,_ ,_) = pprPanic ("MkExternalCore: make_alt: DEFAULT "
 make_lit :: Literal -> C.Lit
 make_lit l = 
   case l of
-    MachChar i -> C.Lchar i t
+    -- Note that we need to check whether the character is "big".
+    -- External Core only allows character literals up to '\xff'.
+    MachChar i | i <= chr 0xff -> C.Lchar i t
+    -- For a character bigger than 0xff, we represent it in ext-core
+    -- as an int lit with a char type.
+    MachChar i             -> C.Lint (fromIntegral $ ord i) t 
     MachStr s -> C.Lstring (unpackFS s) t
     MachNullAddr -> C.Lint 0 t
     MachInt i -> C.Lint i t
@@ -160,7 +185,7 @@ make_ty (TyVarTy tv)         = C.Tvar (make_var_id (tyVarName tv))
 make_ty (AppTy t1 t2)           = C.Tapp (make_ty t1) (make_ty t2)
 make_ty (FunTy t1 t2)           = make_ty (TyConApp funTyCon [t1,t2])
 make_ty (ForAllTy tv t)         = C.Tforall (make_tbind tv) (make_ty t)
-make_ty (TyConApp tc ts)        = foldl C.Tapp (C.Tcon (make_con_qid (tyConName tc))) 
+make_ty (TyConApp tc ts)        = foldl C.Tapp (C.Tcon (qtc tc)) 
                                         (map make_ty ts)
 -- Newtypes are treated just like any other type constructor; not expanded
 -- Reason: predTypeRep does substitution and, while substitution deals
@@ -190,28 +215,29 @@ make_kind _ = error "MkExternalCore died: make_kind"
 
 {- Id generation. -}
 
-{- Use encoded strings.
-   Also, adjust casing to work around some badly-chosen internal names. -}
 make_id :: Bool -> Name -> C.Id
 make_id _is_var nm = (occNameString . nameOccName) nm
 
-{-     SIMON thinks this stuff isn't necessary
-make_id is_var nm = 
-  case n of
-    'Z':cs | is_var -> 'z':cs 
-    'z':cs | not is_var -> 'Z':cs 
-    c:cs | isUpper c && is_var -> 'z':'d':n
-    c:cs | isLower c && (not is_var) -> 'Z':'d':n
-    _ -> n
-  where n = (occNameString . nameOccName) nm
--}
-
 make_var_id :: Name -> C.Id
 make_var_id = make_id True
 
+-- It's important to encode the module name here, because in External Core,
+-- base:GHC.Base => base:GHCziBase
+-- We don't do this in pprExternalCore because we
+-- *do* want to keep the package name (we don't want baseZCGHCziBase,
+-- because that would just be ugly.)
+-- SIGH.
+-- We encode the package name as well.
 make_mid :: Module -> C.Id
-make_mid = showSDoc . pprModule
-
+-- Super ugly code, but I can't find anything else that does quite what I
+-- want (encodes the hierarchical module name without encoding the colon
+-- that separates the package name from it.)
+make_mid m = showSDoc $
+              (text $ zEncodeString $ packageIdString $ modulePackageId m)
+              <> text ":"
+              <> (pprEncoded $ pprModuleName $ moduleName m)
+     where pprEncoded = pprCode CStyle
+               
 make_qid :: Bool -> Name -> C.Qual C.Id
 make_qid is_var n = (mname,make_id is_var n)
     where mname =