X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=CoreTools.hs;h=0c0e1fa7f60d88cd3914b9fcf1c3b20073c3a8ff;hb=b8c1e8554ba8aee73bc9d9a54bb3cb32f7930957;hp=4cafec1b34f8225870b4cb6b32af8ee03505936a;hpb=e12f07ce9f854a28bfc5bd607644644da03fb8d3;p=matthijs%2Fmaster-project%2Fc%CE%BBash.git

diff --git a/CoreTools.hs b/CoreTools.hs
index 4cafec1..0c0e1fa 100644
--- a/CoreTools.hs
+++ b/CoreTools.hs
@@ -6,13 +6,16 @@ module CoreTools where
 
 --Standard modules
 import qualified Maybe
+import System.IO.Unsafe
 
 -- GHC API
 import qualified GHC
 import qualified Type
+import qualified TcType
 import qualified HsExpr
 import qualified HsTypes
 import qualified HsBinds
+import qualified HscTypes
 import qualified RdrName
 import qualified Name
 import qualified OccName
@@ -26,18 +29,21 @@ import qualified VarSet
 import qualified Unique
 import qualified CoreUtils
 import qualified CoreFVs
+import qualified Literal
 
+-- Local imports
 import GhcTools
 import HsTools
+import Pretty
 
 -- | Evaluate a core Type representing type level int from the tfp
 -- library to a real int.
-eval_tfp_int :: Type.Type -> Int
-eval_tfp_int ty =
+eval_tfp_int :: HscTypes.HscEnv -> Type.Type -> Int
+eval_tfp_int env ty =
   unsafeRunGhc $ do
+    GHC.setSession env
     -- Automatically import modules for any fully qualified identifiers
     setDynFlag DynFlags.Opt_ImplicitImportQualified
-    --setDynFlag DynFlags.Opt_D_dump_if_trace
 
     let from_int_t_name = mkRdrName "Types.Data.Num" "fromIntegerT"
     let from_int_t = SrcLoc.noLoc $ HsExpr.HsVar from_int_t_name
@@ -45,24 +51,50 @@ eval_tfp_int ty =
     let app = SrcLoc.noLoc $ HsExpr.HsApp (from_int_t) (undef)
     let int_ty = SrcLoc.noLoc $ HsTypes.HsTyVar TysWiredIn.intTyCon_RDR
     let expr = HsExpr.ExprWithTySig app int_ty
-    let foo_name = mkRdrName "Types.Data.Num" "foo"
-    let foo_bind_name = RdrName.mkRdrUnqual $ OccName.mkVarOcc "foo"
-    let binds = Bag.listToBag [SrcLoc.noLoc $ HsBinds.VarBind foo_bind_name (SrcLoc.noLoc $ HsExpr.HsVar foo_name)]
-    let letexpr = HsExpr.HsLet 
-          (HsBinds.HsValBinds $ (HsBinds.ValBindsIn binds) [])
-          (SrcLoc.noLoc expr)
-
-    let modules = map GHC.mkModuleName ["Types.Data.Num"]
-    core <- toCore modules expr
+    core <- toCore expr
     execCore core 
 
+normalise_tfp_int :: HscTypes.HscEnv -> Type.Type -> Type.Type
+normalise_tfp_int env ty =
+   unsafePerformIO $ do
+     nty <- normaliseType env ty
+     return nty
+
 -- | Get the width of a SizedWord type
-sized_word_len :: Type.Type -> Int
-sized_word_len ty =
-  eval_tfp_int len
-  where 
-    (tycon, args) = Type.splitTyConApp ty
-    [len] = args
+-- sized_word_len :: HscTypes.HscEnv -> Type.Type -> Int
+-- sized_word_len env ty = eval_tfp_int env (sized_word_len_ty ty)
+    
+sized_word_len_ty :: Type.Type -> Type.Type
+sized_word_len_ty ty = len
+  where
+    args = case Type.splitTyConApp_maybe ty of
+      Just (tycon, args) -> args
+      Nothing -> error $ "\nCoreTools.sized_word_len_ty: Not a sized word type: " ++ (pprString ty)
+    [len]         = args
+
+-- | Get the width of a SizedInt type
+-- sized_int_len :: HscTypes.HscEnv -> Type.Type -> Int
+-- sized_int_len env ty = eval_tfp_int env (sized_int_len_ty ty)
+
+sized_int_len_ty :: Type.Type -> Type.Type
+sized_int_len_ty ty = len
+  where
+    args = case Type.splitTyConApp_maybe ty of
+      Just (tycon, args) -> args
+      Nothing -> error $ "\nCoreTools.sized_int_len_ty: Not a sized int type: " ++ (pprString ty)
+    [len]         = args
+    
+-- | Get the upperbound of a RangedWord type
+-- ranged_word_bound :: HscTypes.HscEnv -> Type.Type -> Int
+-- ranged_word_bound env ty = eval_tfp_int env (ranged_word_bound_ty ty)
+    
+ranged_word_bound_ty :: Type.Type -> Type.Type
+ranged_word_bound_ty ty = len
+  where
+    args = case Type.splitTyConApp_maybe ty of
+      Just (tycon, args) -> args
+      Nothing -> error $ "\nCoreTools.ranged_word_bound_ty: Not a sized word type: " ++ (pprString ty)
+    [len]         = args
 
 -- | Evaluate a core Type representing type level int from the TypeLevel
 -- library to a real int.
@@ -81,20 +113,25 @@ sized_word_len ty =
 --     execCore core 
 
 -- | Get the length of a FSVec type
-tfvec_len :: Type.Type -> Int
-tfvec_len ty =
-  eval_tfp_int len
-  where 
-    (tycon, args) = Type.splitTyConApp ty
-    [len, el_ty] = args
+-- tfvec_len :: HscTypes.HscEnv -> Type.Type -> Int
+-- tfvec_len env ty = eval_tfp_int env (tfvec_len_ty ty)
 
--- Is this a wild binder?
-is_wild :: CoreSyn.CoreBndr -> Bool
--- wild binders have a particular unique, that we copied from MkCore.lhs to
--- here. However, this comparison didn't work, so we'll just check the
--- occstring for now... TODO
---(Var.varUnique bndr) == (Unique.mkBuiltinUnique 1)
-is_wild bndr = "wild" == (OccName.occNameString . Name.nameOccName . Var.varName) bndr
+tfvec_len_ty :: Type.Type -> Type.Type
+tfvec_len_ty ty = len
+  where  
+    args = case Type.splitTyConApp_maybe ty of
+      Just (tycon, args) -> args
+      Nothing -> error $ "\nCoreTools.tfvec_len_ty: Not a vector type: " ++ (pprString ty)
+    [len, el_ty] = args
+    
+-- | Get the element type of a TFVec type
+tfvec_elem :: Type.Type -> Type.Type
+tfvec_elem ty = el_ty
+  where
+    args = case Type.splitTyConApp_maybe ty of
+      Just (tycon, args) -> args
+      Nothing -> error $ "\nCoreTools.tfvec_len: Not a vector type: " ++ (pprString ty)
+    [len, el_ty] = args
 
 -- Is the given core expression a lambda abstraction?
 is_lam :: CoreSyn.CoreExpr -> Bool
@@ -119,6 +156,55 @@ is_var :: CoreSyn.CoreExpr -> Bool
 is_var (CoreSyn.Var _) = True
 is_var _ = False
 
+is_lit :: CoreSyn.CoreExpr -> Bool
+is_lit (CoreSyn.Lit _) = True
+is_lit _ = False
+
+-- Can the given core expression be applied to something? This is true for
+-- applying to a value as well as a type.
+is_applicable :: CoreSyn.CoreExpr -> Bool
+is_applicable expr = is_fun expr || is_poly expr
+
+-- Is the given core expression a variable or an application?
+is_simple :: CoreSyn.CoreExpr -> Bool
+is_simple (CoreSyn.App _ _) = True
+is_simple (CoreSyn.Var _) = True
+is_simple (CoreSyn.Cast expr _) = is_simple expr
+is_simple _ = False
+
 -- Does the given CoreExpr have any free type vars?
 has_free_tyvars :: CoreSyn.CoreExpr -> Bool
 has_free_tyvars = not . VarSet.isEmptyVarSet . (CoreFVs.exprSomeFreeVars Var.isTyVar)
+
+-- Does the given CoreExpr have any free local vars?
+has_free_vars :: CoreSyn.CoreExpr -> Bool
+has_free_vars = not . VarSet.isEmptyVarSet . CoreFVs.exprFreeVars
+
+-- Turns a Var CoreExpr into the Id inside it. Will of course only work for
+-- simple Var CoreExprs, not complexer ones.
+exprToVar :: CoreSyn.CoreExpr -> Var.Id
+exprToVar (CoreSyn.Var id) = id
+exprToVar expr = error $ "\nCoreTools.exprToVar: Not a var: " ++ show expr
+
+-- Turns a Lit CoreExpr into the Literal inside it.
+exprToLit :: CoreSyn.CoreExpr -> Literal.Literal
+exprToLit (CoreSyn.Lit lit) = lit
+exprToLit expr = error $ "\nCoreTools.exprToLit: Not a lit: " ++ show expr
+
+-- Removes all the type and dictionary arguments from the given argument list,
+-- leaving only the normal value arguments. The type given is the type of the
+-- expression applied to this argument list.
+get_val_args :: Type.Type -> [CoreSyn.CoreExpr] -> [CoreSyn.CoreExpr]
+get_val_args ty args = drop n args
+  where
+    (tyvars, predtypes, _) = TcType.tcSplitSigmaTy ty
+    -- The first (length tyvars) arguments should be types, the next 
+    -- (length predtypes) arguments should be dictionaries. We drop this many
+    -- arguments, to get at the value arguments.
+    n = length tyvars + length predtypes
+
+getLiterals :: CoreSyn.CoreExpr -> [CoreSyn.CoreExpr]
+getLiterals app@(CoreSyn.App _ _) = literals
+  where
+    (CoreSyn.Var f, args) = CoreSyn.collectArgs app
+    literals = filter (is_lit) args