diff --git a/Epic/Bytecode.lhs b/Epic/Bytecode.lhs --- a/Epic/Bytecode.lhs +++ b/Epic/Bytecode.lhs @@ -1,7 +1,7 @@ > module Epic.Bytecode where > import Control.Monad.State -> import List +> import Data.List > import Epic.Language > import Debug.Trace diff --git a/Epic/CodegenC.lhs b/Epic/CodegenC.lhs --- a/Epic/CodegenC.lhs +++ b/Epic/CodegenC.lhs @@ -20,8 +20,8 @@ > writeIFace :: [Decl] -> String > writeIFace [] = "" -> writeIFace ((Decl name ret (Bind args _ _ _) _ _):xs) = -> "extern " ++ showC name ++ " ("++ showextargs (args) ++ ")" ++ +> writeIFace ((Decl (UN name) ret (Bind args _ _ _) _ _):xs) = +> "extern " ++ name ++ " ("++ showextargs (args) ++ ")" ++ > " -> " ++ show ret ++ "\n" ++ writeIFace xs > writeIFace (_:xs) = writeIFace xs @@ -191,7 +191,7 @@ > cg (EVAL v False) = return $ tmp v ++ "=(void*)EVAL_NOUP((VAL)"++tmp v++");" > cg (EVALINT v True) = return $ tmp v ++ "=(void*)EVALINT((VAL)"++tmp v++");" > cg (EVALINT v False) = return $ tmp v ++ "=(void*)EVALINT_NOUP((VAL)"++tmp v++");" -> cg (RETURN t) = return $ "DROPROOTS; return promote("++tmp t++");" +> cg (RETURN t) = return $ "DROPROOTS; return "++tmp t++";" > cg DRETURN = return $ "DROPROOTS; return NULL;" > cg (ERROR s) = return $ "ERROR("++show s++");" > cg (COMMENT s) = return $ " // " ++ show s diff --git a/Epic/CodegenStack.lhs b/Epic/CodegenStack.lhs new file mode 100644 --- /dev/null +++ b/Epic/CodegenStack.lhs @@ -0,0 +1,21 @@ +> module Epic.CodegenStack where + +> import Control.Monad.State + +> import Epic.Language +> import Epic.Stackcode +> import Debug.Trace + +> codegenC :: Context -> [Decl] -> String +> codegenC ctxt decls = error $ concatMap (worker ctxt) decls + +> codegenH :: String -> [Decl] -> String +> codegenH = undefined + +> writeIFace :: [Decl] -> String +> writeIFace = undefined + +> worker :: Context -> Decl -> String +> worker ctxt (Decl name ty fn exp flags) = +> show (name, compile ctxt name fn) +> worker _ _ = "" diff --git a/Epic/Compiler.lhs b/Epic/Compiler.lhs --- a/Epic/Compiler.lhs +++ b/Epic/Compiler.lhs @@ -17,11 +17,12 @@ Brings everything together; parsing, checking, code generation -> import System +> import System.Process +> import System.Exit > import System.IO > import System.Directory > import System.Environment -> import Char +> import Data.Char > import Epic.Language > import Epic.Parser diff --git a/Epic/Epic.lhs b/Epic/Epic.lhs --- a/Epic/Epic.lhs +++ b/Epic/Epic.lhs @@ -1,4 +1,5 @@ -> {-# OPTIONS_GHC -fglasgow-exts #-} +> {-# LANGUAGE ExistentialQuantification, ScopedTypeVariables, +> FlexibleInstances, TypeSynonymInstances #-} > -- | > -- Module : Epic.Epic @@ -31,11 +32,12 @@ > eq_, lt_, lte_, gt_, gte_, > eqF_, ltF_, lteF_, gtF_, gteF_, shiftl_, shiftr_, > -- * Declarations and programs -> EpicDecl(..), Program, +> EpicDecl(..), Program, mkProgram, > -- * Compiling and execution > Epic.Epic.compile, compileObj, Epic.Epic.link, > Epic.Epic.compileWith, compileObjWith, Epic.Epic.linkWith, > run, +> evaluate, > CompileOptions(..), > -- * Some basic definitions > basic_defs) where @@ -45,9 +47,12 @@ > import Control.Monad.State > import System > import System.IO +> import Debug.Trace > import Epic.Language > import Epic.Compiler +> import Epic.Evaluator +> import Epic.Scopecheck > import Epic.Parser Allow Haskell functions to be used to build expressions. @@ -432,8 +437,12 @@ > instance Show EpicDecl where > show (EpicFn n e) = show (n, evalState (func e) 0) -> type Program = [EpicDecl] +> data Program = Program { epic_decls :: [EpicDecl], +> eval_decls :: [EvalDecl] } +> mkProgram :: [EpicDecl] -> Program +> mkProgram tms = Program tms (map mkEvalDecl tms) + > name :: String -> Name > name = UN @@ -444,6 +453,10 @@ > mkDecl (Epic.Epic.Link f) = Epic.Language.Link f > mkDecl (Epic.Epic.CType f) = Epic.Language.CType f +> mkEvalDecl :: EpicDecl -> EvalDecl +> mkEvalDecl (EpicFn n e) = EDecl n (mkHOAS (doRtoV (evalState (func e) 0))) +> mkEvalDecl _ = EDirective + > -- |Compile a program to an executable > compile :: Program -> FilePath -> IO () > compile = compileWith [] @@ -451,8 +464,8 @@ > -- |Compile a program to an executable, with options > compileWith :: [CompileOptions] -> Program -> FilePath -> IO () > compileWith opts tms outf -> = do compileDecls (outf++".o") Nothing (map mkDecl tms) opts -> Epic.Compiler.link [outf++".o"] outf opts +> = do compileDecls (outf++".o") Nothing (map mkDecl (epic_decls tms)) opts +> Epic.Compiler.link [outf++".o"] outf opts > -- |Compile a program to a .o > compileObj :: Program -> FilePath -> IO () @@ -461,7 +474,7 @@ > -- |Compile a program to a .o, with options > compileObjWith :: [CompileOptions] -> Program -> FilePath -> IO () > compileObjWith opts tms outf -> = compileDecls outf Nothing (map mkDecl tms) opts +> = compileDecls outf Nothing (map mkDecl (epic_decls tms)) opts > -- |Link a collection of object files. By convention, the entry point is > -- the function called 'main'. @@ -479,6 +492,10 @@ > Epic.Epic.compile tms tmpn > system tmpn > return () + +> evaluate :: EpicExpr e => Program -> e -> Expr +> evaluate tms e = eval (eval_decls tms) +> (mkHOAS (doRtoV (evalState (term e) 0))) Some useful functions diff --git a/Epic/Evaluator.lhs b/Epic/Evaluator.lhs new file mode 100644 --- /dev/null +++ b/Epic/Evaluator.lhs @@ -0,0 +1,158 @@ +> {-# OPTIONS_GHC -XFlexibleInstances #-} + +> module Epic.Evaluator(eval) where + +> import Epic.Language + +> import Debug.Trace + +Assume all expressions are in HOAS form - if we see any Vs, or any Updates +then we have an error. Returns expression in standard form. + +> eval :: [EvalDecl] -> Expr -> Expr +> eval ctx e = case ev e of +> Nothing -> quote 0 e +> Just e' -> quote 0 e' +> where +> ev (R n) = case lookupD n ctx of +> Just e' -> ev e' +> Nothing -> return $ R n +> ev (V i) = return $ V i +> ev (App f xs) = do f' <- ev f +> xs' <- mapM ev xs +> evFn f' xs' +> ev (Lazy e) = ev e +> ev (Effect e) = ev e +> ev (Con t es) = do es' <- mapM ev es +> return $ Con t es' +> ev (Proj e i) = do e' <- ev e +> return $ project e' i +> ev (Case e alts) = do e' <- ev e +> docase e' alts +> ev (If x t e) = do x' <- ev x +> case x of +> Const (MkInt 0) -> ev e +> _ -> ev t +> ev (While _ _) = fail "Can't evaluate while" +> ev (WhileAcc _ _ _) = fail "Can't evaluate while" +> ev (Op op x y) = do x' <- ev x +> y' <- ev y +> case (x', y') of +> (Const xv, Const yv) -> return $ doOp op xv yv +> _ -> return $ Op op x' y' +> ev (Let _ _ _ _) = fail "Not in HOAS form (let)" +> ev (LetM _ _ _) = fail "Can't do updates" +> ev (HLet n ty val sc) = do val' <- ev val +> ev (sc val') +> ev (HLam n ty sc) = do let sc' = \x -> case ev (sc x) of +> Nothing -> sc x +> Just v -> v +> return $ HLam n ty sc' +> ev (WithMem a t e) = ev e +> ev (ForeignCall t str args) +> = do args' <- mapM ev (map fst args) +> return $ ForeignCall t str (zip args' (map snd args)) +> ev (LazyForeignCall t str args) +> = do args' <- mapM ev (map fst args) +> return $ LazyForeignCall t str (zip args' (map snd args)) +> ev x = return x + +> evFn (HLam n t sc) (a:as) = do a' <- ev (sc a) +> evFn a' as +> evFn f [] = ev f +> evFn f as = return $ App f as + +> docase c@(Con t as) alts = case fConAlt t as alts of +> Just rhs -> ev rhs +> Nothing -> return $ Case c alts +> docase c@(Const (MkInt i)) alts +> = case fConstAlt i alts of +> Just rhs -> ev rhs +> Nothing -> return $ Case c alts +> docase c alts = return $ Case c alts + +> fConAlt :: Int -> [Expr] -> [CaseAlt] -> Maybe Expr +> fConAlt t args (HAlt t' n rhs : _) +> | t == t' && n == length args = +> substRHS args rhs +> where +> substRHS [] (HExp rhs) = return rhs +> substRHS (x:xs) (HBind n ty rhsf) = substRHS xs (rhsf x) +> fConAlt t args (DefaultCase e : _) = return e +> fConAlt t args (_:xs) = fConAlt t args xs +> fConAlt t args _ = Nothing + +> fConstAlt :: Int -> [CaseAlt] -> Maybe Expr +> fConstAlt t (ConstAlt t' rhs:_) +> | t == t' = return rhs +> fConstAlt t (DefaultCase e : _) = return e +> fConstAlt t (_:xs) = fConstAlt t xs +> fConstAlt t _ = Nothing + +> doOp Plus (MkInt x) (MkInt y) = Const $ MkInt (x+y) +> doOp Minus (MkInt x) (MkInt y) = Const $ MkInt (x-y) +> doOp Times (MkInt x) (MkInt y) = Const $ MkInt (x*y) +> doOp Divide (MkInt x) (MkInt y) = Const $ MkInt (x `div` y) +> doOp Modulo (MkInt x) (MkInt y) = Const $ MkInt (x `mod` y) +> doOp OpEQ (MkInt x) (MkInt y) = bint (x==y) +> doOp OpLT (MkInt x) (MkInt y) = bint (x doOp OpLE (MkInt x) (MkInt y) = bint (x<=y) +> doOp OpGT (MkInt x) (MkInt y) = bint (x>y) +> doOp OpGE (MkInt x) (MkInt y) = bint (x>=y) + +> doOp FPlus (MkFloat x) (MkFloat y) = Const $ MkFloat (x+y) +> doOp FMinus (MkFloat x) (MkFloat y) = Const $ MkFloat (x-y) +> doOp FTimes (MkFloat x) (MkFloat y) = Const $ MkFloat (x*y) +> doOp FDivide (MkFloat x) (MkFloat y) = Const $ MkFloat (x/y) +> doOp OpFEQ (MkFloat x) (MkFloat y) = bint (x==y) +> doOp OpFLT (MkFloat x) (MkFloat y) = bint (x doOp OpFLE (MkFloat x) (MkFloat y) = bint (x<=y) +> doOp OpFGT (MkFloat x) (MkFloat y) = bint (x>y) +> doOp OpFGE (MkFloat x) (MkFloat y) = bint (x>=y) + +> doOp op x y = Op op (Const x) (Const y) + +> bint True = Const $ MkInt 1 +> bint False = Const $ MkInt 0 + +> project :: Expr -> Int -> Expr +> project (Con t as) i | i < length as = as!!i +> project e i = Proj e i + +> lookupD n [] = Nothing +> lookupD n (EDecl en def:xs) | n == en = Just def +> lookupD n (_:xs) = lookupD n xs + +> class Quote a where +> quote :: Int -> a -> a + +> instance Quote a => Quote [a] where +> quote l = map (quote l) + +> instance Quote a => Quote (a, Type) where +> quote l (x,t) = (quote l x, t) + +> instance Quote Expr where +> quote v (App x xs) = App (quote v x) (quote v xs) +> quote v (Lazy x) = Lazy (quote v x) +> quote v (Effect x) = Effect (quote v x) +> quote v (Con t xs) = Con t (quote v xs) +> quote v (Proj x i) = Proj (quote v x) i +> quote v (Case e as) = Case (quote v e) (quote v as) +> quote v (If x y z) = If (quote v x) (quote v y) (quote v z) +> quote v (While x y) = While (quote v x) (quote v y) +> quote v (WhileAcc x y z) = WhileAcc (quote v x) (quote v y) (quote v z) +> quote v (Op o x y) = Op o (quote v x) (quote v y) +> quote v (HLam n ty fn) = Lam n ty (quote (v+1) (fn (V v))) +> quote v (WithMem a x y) = WithMem a (quote v x) (quote v y) +> quote v (ForeignCall t s xs) = ForeignCall t s (quote v xs) +> quote v (LazyForeignCall t s xs) = LazyForeignCall t s (quote v xs) +> quote v x = x + +> instance Quote CaseAlt where +> quote v (HAlt t n rhs) = buildRHS v t [] rhs where +> buildRHS v t acc (HExp e) = Alt t (reverse acc) (quote v e) +> buildRHS v t acc (HBind n ty rhs) +> = buildRHS (v+1) t ((n,ty):acc) (rhs (V v)) +> quote v (ConstAlt c e) = ConstAlt c (quote v e) +> quote v (DefaultCase e) = DefaultCase (quote v e) diff --git a/Epic/Language.lhs b/Epic/Language.lhs --- a/Epic/Language.lhs +++ b/Epic/Language.lhs @@ -1,11 +1,15 @@ +> {-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, +> FunctionalDependencies #-} + > module Epic.Language where > import Control.Monad -> import System > import System.IO > import System.Directory > import System.Environment +> import Debug.Trace + > -- | (Debugging) options to give to compiler > data CompileOptions = KeepC -- ^ Keep intermediate C file > | Trace -- ^ Generate trace at run-time (debug) @@ -34,6 +38,8 @@ > | TyData -- generic data type > | TyCType String -- Exported, C typedef > | TyFun -- any function +> | TyLin Type -- guarantee at most one instance +> | TyEval Type -- guarantee evaluated > deriving Eq > instance Show Type where @@ -50,6 +56,8 @@ > show TyData = "Data" > show (TyCType s) = "CType " ++ s > show TyFun = "Fun" +> show (TyLin s) = "Linear(" ++ show s ++ ")" +> show (TyEval s) = "Eval(" ++ show s ++ ")" > data Const = MkInt Int > | MkBigInt Integer @@ -94,6 +102,8 @@ > type Tag = Int +> type HFun = Expr -> Expr + > data Expr = V Int -- Locally bound name > | R Name -- Global reference > | App Expr [Expr] -- Function application @@ -109,8 +119,10 @@ > | Op Op Expr Expr -- Infix operator > | Let Name Type Expr Expr -- Let binding > | LetM Name Expr Expr -- Update a variable +> | HLet Name Type Expr HFun -- HOAS let, for evaluation > | Update Int Expr Expr -- Update a variable (scope-checked) > | Lam Name Type Expr -- inner lambda +> | HLam Name Type HFun -- HOAS lambda, for evaluation > | Error String -- Exit with error message > | Impossible -- Claimed impossible to reach code > | WithMem Allocator Expr Expr -- evaluate with manual allocation @@ -122,11 +134,24 @@ > alt_args :: [(Name, Type)], -- bound arguments > alt_expr :: Expr -- what to do > } +> | HAlt { alt_tag :: Tag, +> alt_numargs :: Int, +> alt_binds :: HRHS } > | ConstAlt { alt_const :: Int, > alt_expr :: Expr } > | DefaultCase { alt_expr :: Expr } > deriving Eq +> data HRHS = HExp Expr +> | HBind Name Type (Expr -> HRHS) +> deriving Eq + +> instance Eq (Expr -> Expr) where -- can't compare HOAS for equality +> _ == _ = False + +> instance Eq (Expr -> HRHS) where -- can't compare HOAS for equality +> _ == _ = False + > instance Ord CaseAlt where -- only the tag matters > compare (Alt t1 _ _) (Alt t2 _ _) = compare t1 t2 > compare (Alt _ _ _) (DefaultCase _) = LT @@ -206,6 +231,96 @@ > | Link String > | CType String > deriving Show + +> data EvalDecl = EDecl { ename :: Name, +> edef :: Expr -- as HOAS +> } +> | EDirective + +> class SubstV x where +> subst :: Int -> Expr -> x -> x + +> instance SubstV a => SubstV [a] where +> subst v rep xs = map (subst v rep) xs + +> instance SubstV (Expr, Type) where +> subst v rep (x, t) = (subst v rep x, t) + +> instance SubstV Expr where +> subst v rep (V x) | v == x = rep +> subst v rep (App x xs) = App (subst v rep x) (subst v rep xs) +> subst v rep (Lazy x) = Lazy (subst v rep x) +> subst v rep (Effect x) = Effect (subst v rep x) +> subst v rep (Con t xs) = Con t (subst v rep xs) +> subst v rep (Proj x i) = Proj (subst v rep x) i +> subst v rep (Case x alts) = Case (subst v rep x) (subst v rep alts) +> subst v rep (If a t e) +> = If (subst v rep a) (subst v rep t) (subst v rep e) +> subst v rep (While a e) = While (subst v rep a) (subst v rep e) +> subst v rep (WhileAcc a t e) +> = WhileAcc (subst v rep a) (subst v rep t) (subst v rep e) +> subst v rep (Op o x y) = Op o (subst v rep x) (subst v rep y) +> subst v rep (Let n ty val sc) +> = Let n ty (subst v rep val) (subst v rep sc) +> subst v rep (LetM n val sc) +> = LetM n (subst v rep val) (subst v rep sc) +> subst v rep (Lam n t e) = Lam n t (subst v rep e) +> subst v rep (WithMem a x y) = WithMem a (subst v rep x) (subst v rep y) +> subst v rep (ForeignCall t s xs) = ForeignCall t s (subst v rep xs) +> subst v rep (LazyForeignCall t s xs) +> = LazyForeignCall t s (subst v rep xs) +> subst v rep x = x + +> instance SubstV CaseAlt where +> subst v rep (Alt t as e) = Alt t as (subst v rep e) +> subst v rep (ConstAlt i e) = ConstAlt i (subst v rep e) +> subst v rep (DefaultCase e) = DefaultCase (subst v rep e) + +> class HOAS a b | a -> b where +> hoas :: Int -> a -> b +> mkHOAS :: a -> b +> mkHOAS = hoas 0 + +> instance HOAS a a => HOAS [a] [a] where +> hoas v xs = map (hoas v) xs + +> instance HOAS a a => HOAS (a, Type) (a, Type) where +> hoas v (x, t) = (hoas v x, t) + +> instance HOAS Func Expr where +> hoas v (Bind args locs def flags) = hargs v args def where +> hargs v [] def = hoas v def +> hargs v ((x,t):xs) def +> = HLam x t (\var -> hargs (v+1) xs (subst v var def)) + +> instance HOAS Expr Expr where +> hoas v (App f xs) = App (hoas v f) (hoas v xs) +> hoas v (Lazy x) = Lazy (hoas v x) +> hoas v (Effect x) = Effect (hoas v x) +> hoas v (Con t xs) = Con t (hoas v xs) +> hoas v (Proj x i) = Proj (hoas v x) i +> hoas v (Case x xs) = Case (hoas v x) (hoas v xs) +> hoas v (If x t e) = If (hoas v x) (hoas v t) (hoas v e) +> hoas v (While x y) = While (hoas v x) (hoas v y) +> hoas v (WhileAcc x y z) = WhileAcc (hoas v x) (hoas v y) (hoas v z) +> hoas v (Op o x y) = Op o (hoas v x) (hoas v y) +> hoas v (Let n t val sc) +> = HLet n t val (\var -> subst v var (hoas (v+1) sc)) +> hoas v (Lam n ty sc) +> = HLam n ty (\var -> subst v var (hoas (v+1) sc)) +> hoas v (WithMem a x y) = WithMem a (hoas v x) (hoas v y) +> hoas v (ForeignCall t n xs) = ForeignCall t n (hoas v xs) +> hoas v (LazyForeignCall t n xs) = LazyForeignCall t n (hoas v xs) +> hoas v x = x + +> instance HOAS CaseAlt CaseAlt where +> hoas v (Alt t args rhs) = HAlt t (length args) (hbind v args rhs) where +> hbind v [] rhs = HExp (hoas v rhs) +> hbind v ((x,t):xs) rhs +> = HBind x t (\var -> hbind (v+1) xs (subst v var rhs)) +> hoas v (ConstAlt i e) = ConstAlt i (hoas v e) +> hoas v (DefaultCase e) = DefaultCase (hoas v e) + > data CGFlag = Inline | Strict > deriving (Show, Eq) diff --git a/Epic/Lexer.lhs b/Epic/Lexer.lhs --- a/Epic/Lexer.lhs +++ b/Epic/Lexer.lhs @@ -1,6 +1,6 @@ > module Epic.Lexer where -> import Char +> import Data.Char > import Epic.Language @@ -64,6 +64,8 @@ > | TokenAnyType > | TokenDataType > | TokenTyCType +> | TokenTyLinear +> | TokenTyEval > | TokenFunType > | TokenForeign > | TokenCInclude @@ -248,6 +250,8 @@ > ("Unit",rest) -> cont TokenUnitType rest > ("Data",rest) -> cont TokenDataType rest > ("CType",rest) -> cont TokenTyCType rest +> ("Linear",rest) -> cont TokenTyLinear rest +> ("Eval",rest) -> cont TokenTyEval rest > ("Fun",rest) -> cont TokenFunType rest > ("Any",rest) -> cont TokenAnyType rest > -- values diff --git a/Epic/Parser.y b/Epic/Parser.y --- a/Epic/Parser.y +++ b/Epic/Parser.y @@ -1,9 +1,8 @@ { -- -*-Haskell-*- -{-# OPTIONS_GHC -fglasgow-exts #-} module Epic.Parser where -import Char +import Data.Char import System.IO.Unsafe import Epic.Language @@ -41,6 +40,8 @@ funtype { TokenFunType } datatype { TokenDataType } tyctype { TokenTyCType } + tylinear { TokenTyLinear } + tyeval { TokenTyEval } anytype { TokenAnyType } unit { TokenUnit } con { TokenCon } @@ -147,6 +148,8 @@ | anytype { TyAny } | datatype { TyData } | tyctype string { TyCType $2 } + | tylinear '(' Type ')' { TyLin $3 } + | tyeval '(' Type ')' { TyEval $3 } | funtype { TyFun } Declaration :: { Decl } diff --git a/Epic/Scopecheck.lhs b/Epic/Scopecheck.lhs --- a/Epic/Scopecheck.lhs +++ b/Epic/Scopecheck.lhs @@ -1,3 +1,5 @@ +> {-# OPTIONS_GHC -XFlexibleInstances #-} + > module Epic.Scopecheck where Check that an expression has all its names in scope. This is the only @@ -156,12 +158,60 @@ We're being very tolerant of input here... -> v_ise [] _ = [] -> v_ise ((n,ty):args) i = let rest = v_ise args (i+1) in -> case lookup n rest of -> Nothing -> (n,i):rest -> _ -> rest +> v_ise [] _ = [] +> v_ise ((n,ty):args) i = let rest = v_ise args (i+1) in +> case lookup n rest of +> Nothing -> (n,i):rest +> _ -> rest where dropArg n [] = [] dropArg n ((x,i):xs) | x == n = dropArg n xs | otherwise = (x,i):(dropArg n xs) + +This is scope checking without the lambda lifting. Of course, it would be +better to separate the two anyway... FIXME later... + +> class RtoV a where +> rtov :: [(Name, Int)] -> a -> a +> doRtoV :: a -> a +> doRtoV = rtov [] + +> instance RtoV a => RtoV [a] where +> rtov env xs = map (rtov env) xs + +> instance RtoV a => RtoV (a, Type) where +> rtov env (x, t) = (rtov env x, t) + +> instance RtoV Func where +> rtov env (Bind args locs def flags) +> = Bind args locs (rtov (v_ise args 0) def) flags + +> instance RtoV Expr where +> rtov v (R x) = case lookup x v of +> Just i -> V i +> _ -> R x +> rtov v (App f xs) = App (rtov v f) (rtov v xs) +> rtov v (Lazy x) = Lazy (rtov v x) +> rtov v (Effect x) = Effect (rtov v x) +> rtov v (Con t xs) = Con t (rtov v xs) +> rtov v (Proj x i) = Proj (rtov v x) i +> rtov v (Case x xs) = Case (rtov v x) (rtov v xs) +> rtov v (If x t e) = If (rtov v x) (rtov v t) (rtov v e) +> rtov v (While x y) = While (rtov v x) (rtov v y) +> rtov v (WhileAcc x y z) = WhileAcc (rtov v x) (rtov v y) (rtov v z) +> rtov v (Op o x y) = Op o (rtov v x) (rtov v y) +> rtov v (Let n t val sc) +> = Let n t (rtov v val) (rtov ((n,length v):v) sc) +> rtov v (Lam n ty sc) +> = Lam n ty (rtov ((n,length v):v) sc) +> rtov v (WithMem a x y) = WithMem a (rtov v x) (rtov v y) +> rtov v (ForeignCall t n xs) = ForeignCall t n (rtov v xs) +> rtov v (LazyForeignCall t n xs) = LazyForeignCall t n (rtov v xs) +> rtov v x = x + +> instance RtoV CaseAlt where +> rtov v (Alt t args rhs) +> = let env' = (v_ise args (length v)) ++ v in +> Alt t args (rtov env' rhs) +> rtov v (ConstAlt i e) = ConstAlt i (rtov v e) +> rtov v (DefaultCase e) = DefaultCase (rtov v e) diff --git a/Epic/Stackcode.lhs b/Epic/Stackcode.lhs new file mode 100644 --- /dev/null +++ b/Epic/Stackcode.lhs @@ -0,0 +1,212 @@ +> module Epic.Stackcode where + +> import Control.Monad.State +> import List + +> import Epic.Language +> import Debug.Trace + +A stack based byte code. + +Functions take arguments and local variables on the stack and put the +return value at the top of the stack. + +If there are local variables in scope, +locally bound name V n is referred to by stack location (-n) + +> type Loc = Int +> type Tmp = Int + +> data ByteOp = EVAL Loc Bool -- whether to update +> | PUSH Loc +> | INT Int +> | BIGINT Integer +> | FLOAT Float +> | STRING Int -- reference to string pool +> | CON Tag Int +> | UNIT +> | UNUSED +> | THUNK Int Int Name +> | CALL Name +> | SLIDE Int Int +> | DISCARD Int +> | ADDARGS Loc Int +> | PROJ Int Int -- project the nth argument from stack position m +> | CASE [(Int, Bytecode)] (Maybe Bytecode) +> | INTCASE [(Int, Bytecode)] (Maybe Bytecode) +> | IF Bytecode Bytecode -- must discard stack top! +> | MEMORY Allocator Bytecode +> | WHILE Bytecode Bytecode +> | BREAKFALSE +> | OP Op Loc Loc +> | CONSTS [String] +> | FOREIGN Type String [Type] +> | NotImplemented String +> deriving Show + +> type Bytecode = [ByteOp] + +> data FunCode = Code Bytecode +> deriving Show + +> data CompileState = CS { num_locals :: Int, +> string_pool :: [String] } + +> compile :: Context -> Name -> Func -> FunCode +> compile ctxt fname fn@(Bind args locals def flags) = +> let cs = CS (length args) [] +> (code, state) = runState (scompile ctxt fname fn) cs in +> Code code + +> data TailCall = Tail | Middle + +Compiling a function of n arguments replaces top n entries on the stack +with one, the result. SLIDE, at the end, removes the locals. + +> scompile :: Context -> Name -> Func -> State CompileState Bytecode +> scompile ctxt fname (Bind args locals def _) = +> do code <- tcomp False False 1 def +> cs <- get +> return (CONSTS (string_pool cs) : code) + +Assumption: ecomp produces code which makes the stack have one more entry. + +> where ecomp :: Bool -> Bool -> +> Int -> -- variable offset. Stack top is at 1. +> Expr -> +> State CompileState Bytecode +> ecomp lazy eff off (V v) = return [PUSH (off-v)] +> ecomp lazy eff off (R x) = acomp Middle lazy eff off (R x) [] +> ecomp lazy eff off (App f as) = acomp Middle lazy eff off f as +> ecomp lazy eff off (Lazy e) = ecomp True eff off e +> ecomp lazy eff off (Effect e) = +> do code <- ecomp lazy True off e +> return (code ++ [EVAL 1 False]) +> ecomp lazy eff off (Con t as) = +> do argcode <- argcomp lazy eff off as +> return (argcode ++ [CON t (length as)]) +> ecomp lazy eff off (Proj con i) = +> do concode <- ecomp lazy eff off con +> return (concode ++ [PROJ i 0]) +> ecomp lazy eff off (Const c) = ccomp c +> ecomp lazy eff off (Case scr alts) = +> do sccode <- ecomp lazy eff off scr +> (altcode, def) <- altcomps lazy eff Middle off (order alts) +> return $ sccode ++ [EVAL 0 eff, (caseop alts) altcode def] +> ecomp lazy eff off (If a t e) = +> do acode <- ecomp lazy eff off a +> tcode <- tcomp lazy eff off t +> ecode <- tcomp lazy eff off e +> return (acode ++ [EVAL 0 eff, IF tcode ecode]) +> ecomp lazy eff off (WithMem a e val) = +> do ecode <- ecomp lazy eff off e +> valcode <- ecomp lazy eff off val +> return $ ecode ++ [EVAL 0 eff] ++ [MEMORY a valcode] +> ecomp lazy eff off (While t b) = +> do tcode <- ecomp lazy eff off t +> bcode <- ecomp lazy eff off b +> return [WHILE (tcode ++ [EVAL 0 False, BREAKFALSE]) +> (bcode ++ [EVAL 0 False])] +> ecomp lazy eff off (WhileAcc t acc b) = +> do tcode <- ecomp lazy eff off t +> acode <- ecomp lazy eff off acc +> bcode <- ecomp lazy eff off b +> return $ acode ++ +> [WHILE (tcode ++ [EVAL 0 False, BREAKFALSE]) +> (bcode ++ [ADDARGS 2 1, EVAL 2 False])] +> {- ecomp lazy eff off (ForeignCall ty nm args) +> = fcomp lazy eff off f as +> ecomp lazy eff off (LazyForeignCall ty nm args) +> = fcomp lazy eff off f as -} +> ecomp lzy eff off x = return $ [NotImplemented (show x)] + +Compile case alternatives. + +> order :: [CaseAlt] -> [CaseAlt] +> order xs = sort xs -- insertError 0 (sort xs) + +> altcomps :: Bool -> Bool -> TailCall -> Int -> +> [CaseAlt] -> +> State CompileState ([(Int, Bytecode)], Maybe Bytecode) +> altcomps lazy eff tc off [] = return ([], Nothing) +> altcomps lazy eff tc off (a:as) = +> do (t,acode) <- altcomp lazy eff tc off a +> (ascode, def) <- altcomps lazy eff tc off as +> if (t<0) then return (ascode, Just acode) +> else return ((t,acode):ascode, def) + +Assume that all the tags are in order, and unused constructors have +a default inserted (i.e., tag can be ignored). + +Return the tag and the code - tag is -1 for default case. + +> altcomp :: Bool -> Bool -> TailCall -> Int -> +> CaseAlt -> +> State CompileState (Int, Bytecode) +> altcomp lazy eff tc off (Alt tag nmargs expr) = +> do let args = map snd nmargs +> projcode <- project args 1 0 +> exprcode <- ecomp lazy eff (off+length args) expr +> return (tag, projcode ++ [SLIDE 1 (length args)] ++ exprcode ++ [SLIDE (length args) 1]) +> altcomp lazy eff tc off (ConstAlt tag expr) = +> do exprcode <- ecomp lazy eff off expr +> return (tag, (SLIDE 1 1):exprcode) +> altcomp lazy eff tc off (DefaultCase expr) = +> do exprcode <- ecomp lazy eff off expr +> return (-1,(SLIDE 1 1):exprcode) + +> project [] _ _ = return [] +> project (_:as) p o = +> do let acode = PROJ p o +> ascode <- project as (p+1) (o+1) +> return (acode:ascode) + +> caseop ((ConstAlt _ _):_) = INTCASE +> caseop _ = CASE + +> tcomp lazy eff off x = +> do code <- ecomp lazy eff off x +> return (code ++ [SLIDE off 1]) + +> acomp :: TailCall -> Bool -> Bool -> Int -> +> Expr -> [Expr] -> +> State CompileState Bytecode +> acomp tl lazy eff off (R x) args +> | not lazy && arity x ctxt == length args = +> do argcode <- argcomp lazy eff off args +> return (argcode ++ cleanstack tl off (length args) +> ++ [CALL x]) +> | otherwise = +> do argcode <- argcomp lazy eff off args +> return (argcode ++ cleanstack tl off (length args) +> ++ [THUNK (arity x ctxt) (length args) x]) +> acomp tl lazy eff off f args +> = do argcode <- argcomp lazy eff off args +> fcode <- ecomp lazy eff off f +> return $ fcode ++ argcode ++ [ADDARGS (length args) (length args)] + +> cleanstack Middle _ n = [] +> cleanstack Tail off n = [SLIDE (off-1) n] + +> argcomp lazy eff off [] = return [] +> argcomp lazy eff off (a:as) = +> do code <- ecomp lazy eff off a +> acode <- argcomp lazy eff (off+1) as +> return (code ++ acode) + +> ccomp (MkInt i) = return [INT i] +> ccomp (MkBigInt i) = return [BIGINT i] +> ccomp (MkChar c) = return [INT (fromEnum c)] +> ccomp (MkFloat f) = return [FLOAT f] +> -- ccomp (MkBigFloat f) = return [BIGFLOAT f] +> ccomp (MkBool b) = return [INT (if b then 1 else 0)] +> ccomp (MkString s) = do sreg <- new_string s +> return [STRING sreg] +> ccomp (MkUnit) = return [UNIT] +> ccomp MkUnused = return [UNUSED] + +> new_string :: String -> State CompileState Int +> new_string s = do cs <- get +> let reg' = string_pool cs +> put (cs { string_pool = reg'++[s] } ) +> return (length reg') diff --git a/Main.lhs b/Main.lhs --- a/Main.lhs +++ b/Main.lhs @@ -1,11 +1,11 @@ > module Main where -> import System +> import System.Exit > import System.Directory > import System.Environment > import System.IO > import Distribution.Version -> import Monad +> import Control.Monad > import Epic.Compiler > import Paths_epic diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -3,7 +3,8 @@ import Distribution.Simple.LocalBuildInfo import Distribution.PackageDescription -import System +import System.Exit +import System.Process -- After Epic is built, we need a run time system. diff --git a/dist/build/Epic/Parser.hs b/dist/build/Epic/Parser.hs deleted file mode 100644 --- a/dist/build/Epic/Parser.hs +++ /dev/null @@ -1,1587 +0,0 @@ -{-# OPTIONS_GHC -fno-warn-overlapping-patterns #-} -{-# OPTIONS -fglasgow-exts -cpp #-} --- -*-Haskell-*- -{-# OPTIONS_GHC -fglasgow-exts #-} - -module Epic.Parser where - -import Char -import System.IO.Unsafe - -import Epic.Language -import Epic.Lexer -import qualified Data.Array as Happy_Data_Array -import qualified GHC.Exts as Happy_GHC_Exts - --- parser produced by Happy Version 1.18.5 - -newtype HappyAbsSyn = HappyAbsSyn HappyAny -#if __GLASGOW_HASKELL__ >= 607 -type HappyAny = Happy_GHC_Exts.Any -#else -type HappyAny = forall a . a -#endif -happyIn6 :: ([Decl]) -> (HappyAbsSyn ) -happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn6 #-} -happyOut6 :: (HappyAbsSyn ) -> ([Decl]) -happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut6 #-} -happyIn7 :: (Type) -> (HappyAbsSyn ) -happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn7 #-} -happyOut7 :: (HappyAbsSyn ) -> (Type) -happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut7 #-} -happyIn8 :: (Decl) -> (HappyAbsSyn ) -happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn8 #-} -happyOut8 :: (HappyAbsSyn ) -> (Decl) -happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut8 #-} -happyIn9 :: ([CGFlag]) -> (HappyAbsSyn ) -happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn9 #-} -happyOut9 :: (HappyAbsSyn ) -> ([CGFlag]) -happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut9 #-} -happyIn10 :: (CGFlag) -> (HappyAbsSyn ) -happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn10 #-} -happyOut10 :: (HappyAbsSyn ) -> (CGFlag) -happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut10 #-} -happyIn11 :: (Maybe String) -> (HappyAbsSyn ) -happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn ) -> (Maybe String) -happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut11 #-} -happyIn12 :: ([(Name,Type)]) -> (HappyAbsSyn ) -happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn ) -> ([(Name,Type)]) -happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut12 #-} -happyIn13 :: (Expr) -> (HappyAbsSyn ) -happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn ) -> (Expr) -happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut13 #-} -happyIn14 :: (Allocator) -> (HappyAbsSyn ) -happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn ) -> (Allocator) -happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut14 #-} -happyIn15 :: (Expr) -> (HappyAbsSyn ) -happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn ) -> (Expr) -happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut15 #-} -happyIn16 :: ([CaseAlt]) -> (HappyAbsSyn ) -happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn ) -> ([CaseAlt]) -happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut16 #-} -happyIn17 :: (CaseAlt) -> (HappyAbsSyn ) -happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn ) -> (CaseAlt) -happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut17 #-} -happyIn18 :: (Expr) -> (HappyAbsSyn ) -happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn ) -> (Expr) -happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut18 #-} -happyIn19 :: ([Expr]) -> (HappyAbsSyn ) -happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn19 #-} -happyOut19 :: (HappyAbsSyn ) -> ([Expr]) -happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut19 #-} -happyIn20 :: ([(Expr,Type)]) -> (HappyAbsSyn ) -happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn ) -> ([(Expr,Type)]) -happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut20 #-} -happyIn21 :: (Const) -> (HappyAbsSyn ) -happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn21 #-} -happyOut21 :: (HappyAbsSyn ) -> (Const) -happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut21 #-} -happyIn22 :: (LineNumber) -> (HappyAbsSyn ) -happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn ) -> (LineNumber) -happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut22 #-} -happyIn23 :: (String) -> (HappyAbsSyn ) -happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn ) -> (String) -happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut23 #-} -happyInTok :: (Token) -> (HappyAbsSyn ) -happyInTok x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyInTok #-} -happyOutTok :: (HappyAbsSyn ) -> (Token) -happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOutTok #-} - - -happyActOffsets :: HappyAddr -happyActOffsets = HappyA# "\x67\x03\x01\x00\x29\x00\x29\x00\x00\x00\xdb\xff\x3f\x02\x25\x02\x23\x02\x22\x02\xca\x01\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x09\x00\x01\x00\x01\x00\xdd\x01\xdc\x01\x00\x00\x25\x00\xdb\x01\x34\x00\x03\x02\x00\x00\x01\x00\x01\x00\x01\x00\x01\x00\xff\x01\x75\x01\x52\x02\xf1\x01\x67\x03\x00\x00\xa2\x01\xe6\xff\xe6\xff\x3f\x01\xb8\x01\xf7\x01\x00\x00\xe5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x01\x00\x00\x01\x00\x34\x00\x01\x00\xf7\x00\x01\x00\x4b\x00\x21\x00\x8d\x01\xc8\x01\x9d\x01\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\xb5\x01\x01\x00\x00\x00\x00\x00\x83\x01\x00\x00\xac\x01\xdb\xff\x00\x00\x00\x00\x00\x00\x81\x01\xaa\x01\x4b\x02\x00\x00\x67\x02\x67\x02\x67\x02\x67\x02\x7f\x02\x7f\x02\x67\x02\x67\x02\x2f\x02\x67\x02\x67\x02\x2f\x02\xe6\xff\xe6\xff\x02\x00\x02\x00\xe6\xff\xe6\xff\xe6\xff\x02\x00\x02\x00\x6d\x01\x01\x00\x6c\x01\x34\x00\x62\x01\x01\x00\x23\x01\x44\x01\x00\x00\x00\x00\xd8\x01\x8b\x01\xb9\x01\x00\x00\x61\x01\x00\x00\x00\x00\x01\x00\x34\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x01\x00\x00\x00\x4e\x01\x00\x00\x01\x00\x01\x00\x67\x00\x0b\x00\x35\x01\x01\x00\x42\x01\x00\x00\x31\x01\x0c\x01\x51\x01\x0b\x01\x34\x00\xd7\x00\x00\x00\xcc\x00\x01\x00\x08\x01\xf6\x00\xcd\x00\x17\x01\xc5\x00\x01\x00\xeb\x00\x07\x01\x01\x00\x9a\x01\xda\x00\x01\x00\x13\x02\x00\x00\x34\x00\xd0\x00\x01\x00\x00\x00\x01\x00\x13\x02\x01\x00\xcf\x00\x01\x00\x0b\x00\x00\x00\xa9\x00\x01\x00\x34\x00\xac\x00\xa6\x00\x34\x00\xe2\x00\x00\x00\x13\x02\x01\x00\x00\x00\x13\x02\xe2\x00\x13\x02\x7e\x01\x5f\x01\x00\x00\x8f\x00\x01\x00\x00\x00\x00\x00\xab\x00\x13\x02\x00\x00\x95\x00\x01\x00\x7c\x00\x00\x00\x01\x00\x13\x02\x13\x02\x00\x00"# - -happyGotoOffsets :: HappyAddr -happyGotoOffsets = HappyA# "\xb0\x03\x9e\x03\x2f\x00\x0a\x00\x00\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x03\x94\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x8b\x03\xb9\x02\x8a\x03\x81\x03\x00\x00\x00\x00\xac\x03\x00\x00\xa6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\xb2\x00\x77\x03\x99\x00\x76\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x02\x6d\x03\x6c\x03\x63\x03\x62\x03\x59\x03\x58\x03\x4f\x03\x4e\x03\x45\x03\x44\x03\x3b\x03\x3a\x03\x31\x03\x30\x03\x27\x03\x26\x03\x1d\x03\x1c\x03\x13\x03\x12\x03\x09\x03\x00\x00\x08\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x6d\x00\x00\x00\xff\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x5a\x00\x5b\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x00\x00\x00\x00\xfe\x02\xf5\x02\x00\x00\x8b\x00\x00\x00\xf4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\xeb\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x02\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\xe1\x02\x00\x00\x00\x00\x38\x00\x00\x00\xe0\x02\x00\x00\xd7\x02\x00\x00\xd6\x02\x00\x00\xcd\x02\x14\x00\x00\x00\x00\x00\xcc\x02\x31\x00\x00\x00\x00\x00\x26\x00\x1f\x00\x00\x00\x00\x00\xc3\x02\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x02\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00"# - -happyDefActions :: HappyAddr -happyDefActions = HappyA# "\xe4\xff\x00\x00\xe4\xff\x00\x00\x00\x00\xe8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\xff\xcd\xff\xd8\xff\xdf\xff\x9c\xff\xa2\xff\xa1\xff\x9f\xff\x9e\xff\x9d\xff\xa0\xff\x9b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\xff\x00\x00\x00\x00\x00\x00\x00\x00\xcb\xff\x00\x00\xa8\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xff\x00\x00\xe4\xff\xfb\xff\x00\x00\xb7\xff\xbd\xff\xa7\xff\x00\x00\x00\x00\xcc\xff\x00\x00\xf9\xff\xf8\xff\xf7\xff\xf6\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xed\xff\xef\xff\x00\x00\xf0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\xff\xe3\xff\x00\x00\xea\xff\x00\x00\xe8\xff\xe5\xff\xe6\xff\xe7\xff\x00\x00\xe2\xff\xd3\xff\xd7\xff\xac\xff\xad\xff\xb1\xff\xb2\xff\xb3\xff\xb4\xff\xaa\xff\xab\xff\xa9\xff\xaf\xff\xb0\xff\xae\xff\xb5\xff\xb6\xff\xb8\xff\xb9\xff\xba\xff\xbb\xff\xbc\xff\xbe\xff\xbf\xff\x00\x00\xa8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\xc7\xff\x00\x00\x00\x00\x00\x00\xee\xff\x00\x00\xde\xff\xdc\xff\xa8\xff\x00\x00\x98\xff\xfa\xff\x00\x00\xa6\xff\xa5\xff\xda\xff\x00\x00\xdb\xff\x00\x00\x00\x00\x00\x00\xc5\xff\x00\x00\x00\x00\x00\x00\xdd\xff\x00\x00\x00\x00\xe2\xff\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x00\x00\x00\x00\xc4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\xff\x00\x00\x00\x00\x00\x00\xd4\xff\xca\xff\x00\x00\x00\x00\x00\x00\xd1\xff\x00\x00\xd2\xff\x00\x00\x00\x00\x00\x00\xc5\xff\xc6\xff\x00\x00\x00\x00\x00\x00\xe1\xff\x00\x00\x00\x00\xe2\xff\xeb\xff\xd5\xff\x00\x00\xc3\xff\xc1\xff\xe2\xff\xc0\xff\x00\x00\x00\x00\xc9\xff\xa4\xff\xa5\xff\xcf\xff\xd0\xff\x00\x00\xd6\xff\xe0\xff\x00\x00\x00\x00\x00\x00\xa3\xff\x00\x00\xec\xff\xc2\xff"# - -happyCheck :: HappyAddr -happyCheck = HappyA# "\xff\xff\x26\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x01\x00\x07\x00\x02\x00\x09\x00\x03\x00\x05\x00\x0c\x00\x2b\x00\x0e\x00\x0f\x00\x07\x00\x06\x00\x09\x00\x16\x00\x17\x00\x0c\x00\x19\x00\x1a\x00\x0f\x00\x1c\x00\x0a\x00\x0b\x00\x1f\x00\x20\x00\x17\x00\x18\x00\x23\x00\x06\x00\x25\x00\x01\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2b\x00\x48\x00\x54\x00\x2f\x00\x02\x00\x01\x00\x32\x00\x05\x00\x33\x00\x34\x00\x35\x00\x37\x00\x01\x00\x38\x00\x39\x00\x1b\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x48\x00\x01\x00\x2b\x00\x28\x00\x4d\x00\x06\x00\x2b\x00\x48\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x1d\x00\x48\x00\x49\x00\x07\x00\x11\x00\x09\x00\x01\x00\x07\x00\x0c\x00\x09\x00\x0e\x00\x0f\x00\x0c\x00\x0d\x00\x2b\x00\x0f\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x1e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x0a\x00\x0b\x00\x06\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x08\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x03\x00\x04\x00\x01\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x4e\x00\x48\x00\x49\x00\x24\x00\x07\x00\x3a\x00\x09\x00\x03\x00\x04\x00\x0c\x00\x2b\x00\x0e\x00\x0f\x00\x2c\x00\x55\x00\x4a\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x24\x00\x48\x00\x49\x00\x07\x00\x4e\x00\x09\x00\x4a\x00\x2b\x00\x0c\x00\x0d\x00\x2b\x00\x0f\x00\x2c\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x4e\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x21\x00\x22\x00\x03\x00\x4e\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x4e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x4a\x00\x2e\x00\x2c\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x4b\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x4a\x00\x01\x00\x47\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x4a\x00\x2c\x00\x3a\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2b\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x4c\x00\x48\x00\x49\x00\x4a\x00\x2b\x00\x2c\x00\x2b\x00\x02\x00\x4a\x00\x2d\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x3a\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x01\x00\x2b\x00\x01\x00\x2b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x03\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x2b\x00\x01\x00\x55\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x47\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x02\x00\x02\x00\x30\x00\x47\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x02\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x01\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x02\x00\x2b\x00\x2b\x00\x2b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x03\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x55\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x02\x00\x02\x00\x01\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x41\x00\x42\x00\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x07\x00\xff\xff\x09\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x07\x00\x0f\x00\x09\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x48\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x00\x00\x09\x00\x02\x00\xff\xff\x0c\x00\x05\x00\x00\x00\x0f\x00\x02\x00\xff\xff\x00\x00\x05\x00\x02\x00\xff\xff\xff\xff\x05\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# - -happyTable :: HappyAddr -happyTable = HappyA# "\x00\x00\x6c\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x4b\x00\xbc\x00\x04\x00\x0c\x00\xb6\x00\x05\x00\x0d\x00\x4e\x00\xe7\x00\x0e\x00\xea\x00\xe1\x00\x0c\x00\x18\x00\x19\x00\x0d\x00\x1a\x00\x1b\x00\x0e\x00\x1c\x00\xd6\x00\xb4\x00\x1d\x00\x1e\x00\xb7\x00\xb8\x00\x1f\x00\xe3\x00\x20\x00\xe4\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x4e\x00\x64\x00\x6d\x00\x26\x00\x0a\x00\xd3\x00\x27\x00\x05\x00\x51\x00\x52\x00\x53\x00\x28\x00\xdd\x00\x56\x00\x57\x00\x8c\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x64\x00\xcf\x00\x4e\x00\x45\x00\x29\x00\xad\x00\x46\x00\x4c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x9c\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x8d\x00\x64\x00\x65\x00\xbc\x00\x9b\x00\x0c\x00\xa6\x00\x31\x00\x0d\x00\x0c\x00\xc2\x00\x0e\x00\x0d\x00\x9d\x00\x4e\x00\x0e\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xb9\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xb3\x00\xb4\x00\xaa\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x8e\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x6d\x00\x6a\x00\x92\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x35\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xe9\x00\x64\x00\x65\x00\xd6\x00\xbc\x00\xe6\x00\x0c\x00\x69\x00\x6a\x00\x0d\x00\x4e\x00\xbd\x00\x0e\x00\xe7\x00\xff\xff\xdf\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xac\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xce\x00\x64\x00\x65\x00\x31\x00\xd2\x00\x0c\x00\xd3\x00\x4e\x00\x0d\x00\xa8\x00\xd9\x00\x0e\x00\xdd\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xc1\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xc8\x00\x64\x00\x65\x00\x4e\x00\xc5\x00\x90\x00\x91\x00\xc9\x00\xca\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xcf\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xc6\x00\xcc\x00\xd1\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xcb\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xc4\x00\xac\x00\xaf\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xb0\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xa4\x00\xb1\x00\xb3\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xbc\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xbf\x00\x64\x00\x65\x00\x99\x00\x4e\x00\xe0\x00\x9f\x00\xa1\x00\xa3\x00\xa6\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xaa\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xa8\x00\x64\x00\x65\x00\x4e\x00\xe1\x00\xac\x00\xad\x00\x6f\x00\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x72\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x89\x00\x8a\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x8b\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xc2\x00\x64\x00\x65\x00\x4e\x00\xa0\x00\x95\x00\x96\x00\x98\x00\x9a\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x2d\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x2f\x00\x64\x00\x65\x00\x4e\x00\xa2\x00\x35\x00\x44\x00\x47\x00\x48\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x4d\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x64\x00\x65\x00\x4e\x00\x97\x00\x66\x00\x67\x00\x68\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x69\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x59\x00\x5a\x00\x00\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x59\x00\x5a\x00\x00\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x2c\x00\x00\x00\xfc\xff\x5e\x00\x5f\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x31\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x0d\x00\x87\x00\x31\x00\x0e\x00\x0c\x00\x00\x00\x00\x00\x0d\x00\x32\x00\x64\x00\x0e\x00\xe9\x00\xe2\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xd4\x00\xd7\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xd9\x00\xda\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xdb\x00\xbf\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xc6\x00\xcc\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xb1\x00\xb9\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xba\x00\xa4\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x70\x00\x72\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x73\x00\x74\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x75\x00\x76\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x77\x00\x78\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x79\x00\x7a\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x7b\x00\x7c\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x7d\x00\x7e\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x7f\x00\x80\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x81\x00\x82\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x83\x00\x84\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x85\x00\x86\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x8d\x00\x91\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x93\x00\x2f\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x30\x00\x33\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x48\x00\x49\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x0b\x00\x9a\x00\x0c\x00\x2a\x00\x00\x00\x0d\x00\x05\x00\x2d\x00\x0e\x00\x2a\x00\x00\x00\x29\x00\x05\x00\x2a\x00\x00\x00\x00\x00\x05\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyReduceArr = Happy_Data_Array.array (3, 103) [ - (3 , happyReduce_3), - (4 , happyReduce_4), - (5 , happyReduce_5), - (6 , happyReduce_6), - (7 , happyReduce_7), - (8 , happyReduce_8), - (9 , happyReduce_9), - (10 , happyReduce_10), - (11 , happyReduce_11), - (12 , happyReduce_12), - (13 , happyReduce_13), - (14 , happyReduce_14), - (15 , happyReduce_15), - (16 , happyReduce_16), - (17 , happyReduce_17), - (18 , happyReduce_18), - (19 , happyReduce_19), - (20 , happyReduce_20), - (21 , happyReduce_21), - (22 , happyReduce_22), - (23 , happyReduce_23), - (24 , happyReduce_24), - (25 , happyReduce_25), - (26 , happyReduce_26), - (27 , happyReduce_27), - (28 , happyReduce_28), - (29 , happyReduce_29), - (30 , happyReduce_30), - (31 , happyReduce_31), - (32 , happyReduce_32), - (33 , happyReduce_33), - (34 , happyReduce_34), - (35 , happyReduce_35), - (36 , happyReduce_36), - (37 , happyReduce_37), - (38 , happyReduce_38), - (39 , happyReduce_39), - (40 , happyReduce_40), - (41 , happyReduce_41), - (42 , happyReduce_42), - (43 , happyReduce_43), - (44 , happyReduce_44), - (45 , happyReduce_45), - (46 , happyReduce_46), - (47 , happyReduce_47), - (48 , happyReduce_48), - (49 , happyReduce_49), - (50 , happyReduce_50), - (51 , happyReduce_51), - (52 , happyReduce_52), - (53 , happyReduce_53), - (54 , happyReduce_54), - (55 , happyReduce_55), - (56 , happyReduce_56), - (57 , happyReduce_57), - (58 , happyReduce_58), - (59 , happyReduce_59), - (60 , happyReduce_60), - (61 , happyReduce_61), - (62 , happyReduce_62), - (63 , happyReduce_63), - (64 , happyReduce_64), - (65 , happyReduce_65), - (66 , happyReduce_66), - (67 , happyReduce_67), - (68 , happyReduce_68), - (69 , happyReduce_69), - (70 , happyReduce_70), - (71 , happyReduce_71), - (72 , happyReduce_72), - (73 , happyReduce_73), - (74 , happyReduce_74), - (75 , happyReduce_75), - (76 , happyReduce_76), - (77 , happyReduce_77), - (78 , happyReduce_78), - (79 , happyReduce_79), - (80 , happyReduce_80), - (81 , happyReduce_81), - (82 , happyReduce_82), - (83 , happyReduce_83), - (84 , happyReduce_84), - (85 , happyReduce_85), - (86 , happyReduce_86), - (87 , happyReduce_87), - (88 , happyReduce_88), - (89 , happyReduce_89), - (90 , happyReduce_90), - (91 , happyReduce_91), - (92 , happyReduce_92), - (93 , happyReduce_93), - (94 , happyReduce_94), - (95 , happyReduce_95), - (96 , happyReduce_96), - (97 , happyReduce_97), - (98 , happyReduce_98), - (99 , happyReduce_99), - (100 , happyReduce_100), - (101 , happyReduce_101), - (102 , happyReduce_102), - (103 , happyReduce_103) - ] - -happy_n_terms = 86 :: Int -happy_n_nonterms = 18 :: Int - -happyReduce_3 = happySpecReduce_1 0# happyReduction_3 -happyReduction_3 happy_x_1 - = case happyOut8 happy_x_1 of { happy_var_1 -> - happyIn6 - ([happy_var_1] - )} - -happyReduce_4 = happySpecReduce_2 0# happyReduction_4 -happyReduction_4 happy_x_2 - happy_x_1 - = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn6 - (happy_var_1:happy_var_2 - )}} - -happyReduce_5 = happyMonadReduce 4# 0# happyReduction_5 -happyReduction_5 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut23 happy_x_4 of { happy_var_4 -> - ( - let rest = happy_var_3 in - let pt = unsafePerformIO (readFile happy_var_2) in - case (parse pt happy_var_4) of - Success x -> returnP (x ++ rest) - Failure err file ln -> failP err)}}} - ) (\r -> happyReturn (happyIn6 r)) - -happyReduce_6 = happySpecReduce_1 1# happyReduction_6 -happyReduction_6 happy_x_1 - = happyIn7 - (TyInt - ) - -happyReduce_7 = happySpecReduce_1 1# happyReduction_7 -happyReduction_7 happy_x_1 - = happyIn7 - (TyBigInt - ) - -happyReduce_8 = happySpecReduce_1 1# happyReduction_8 -happyReduction_8 happy_x_1 - = happyIn7 - (TyChar - ) - -happyReduce_9 = happySpecReduce_1 1# happyReduction_9 -happyReduction_9 happy_x_1 - = happyIn7 - (TyBool - ) - -happyReduce_10 = happySpecReduce_1 1# happyReduction_10 -happyReduction_10 happy_x_1 - = happyIn7 - (TyFloat - ) - -happyReduce_11 = happySpecReduce_1 1# happyReduction_11 -happyReduction_11 happy_x_1 - = happyIn7 - (TyBigFloat - ) - -happyReduce_12 = happySpecReduce_1 1# happyReduction_12 -happyReduction_12 happy_x_1 - = happyIn7 - (TyString - ) - -happyReduce_13 = happySpecReduce_1 1# happyReduction_13 -happyReduction_13 happy_x_1 - = happyIn7 - (TyPtr - ) - -happyReduce_14 = happySpecReduce_1 1# happyReduction_14 -happyReduction_14 happy_x_1 - = happyIn7 - (TyUnit - ) - -happyReduce_15 = happySpecReduce_1 1# happyReduction_15 -happyReduction_15 happy_x_1 - = happyIn7 - (TyAny - ) - -happyReduce_16 = happySpecReduce_1 1# happyReduction_16 -happyReduction_16 happy_x_1 - = happyIn7 - (TyData - ) - -happyReduce_17 = happySpecReduce_2 1# happyReduction_17 -happyReduction_17 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn7 - (TyCType happy_var_2 - )} - -happyReduce_18 = happySpecReduce_1 1# happyReduction_18 -happyReduction_18 happy_x_1 - = happyIn7 - (TyFun - ) - -happyReduce_19 = happyReduce 10# 2# happyReduction_19 -happyReduction_19 (happy_x_10 `HappyStk` - happy_x_9 `HappyStk` - happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut11 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokenName happy_var_3) -> - case happyOut12 happy_x_5 of { happy_var_5 -> - case happyOut7 happy_x_8 of { happy_var_8 -> - case happyOut13 happy_x_10 of { happy_var_10 -> - happyIn8 - (mkBind happy_var_3 (map snd happy_var_5) happy_var_8 (map fst happy_var_5) happy_var_10 happy_var_1 happy_var_2 - ) `HappyStk` happyRest}}}}}} - -happyReduce_20 = happyReduce 7# 2# happyReduction_20 -happyReduction_20 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenName happy_var_2) -> - case happyOut12 happy_x_4 of { happy_var_4 -> - case happyOut7 happy_x_7 of { happy_var_7 -> - happyIn8 - (mkExtern happy_var_2 (map snd happy_var_4) happy_var_7 (map fst happy_var_4) - ) `HappyStk` happyRest}}} - -happyReduce_21 = happySpecReduce_2 2# happyReduction_21 -happyReduction_21 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn8 - (Include happy_var_2 - )} - -happyReduce_22 = happySpecReduce_2 2# happyReduction_22 -happyReduction_22 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn8 - (CType happy_var_2 - )} - -happyReduce_23 = happySpecReduce_0 3# happyReduction_23 -happyReduction_23 = happyIn9 - ([] - ) - -happyReduce_24 = happySpecReduce_2 3# happyReduction_24 -happyReduction_24 happy_x_2 - happy_x_1 - = case happyOut10 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_2 of { happy_var_2 -> - happyIn9 - (happy_var_1:happy_var_2 - )}} - -happyReduce_25 = happySpecReduce_1 4# happyReduction_25 -happyReduction_25 happy_x_1 - = happyIn10 - (Inline - ) - -happyReduce_26 = happySpecReduce_1 4# happyReduction_26 -happyReduction_26 happy_x_1 - = happyIn10 - (Strict - ) - -happyReduce_27 = happySpecReduce_0 5# happyReduction_27 -happyReduction_27 = happyIn11 - (Nothing - ) - -happyReduce_28 = happySpecReduce_2 5# happyReduction_28 -happyReduction_28 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn11 - (Just happy_var_2 - )} - -happyReduce_29 = happySpecReduce_0 6# happyReduction_29 -happyReduction_29 = happyIn12 - ([] - ) - -happyReduce_30 = happySpecReduce_3 6# happyReduction_30 -happyReduction_30 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokenName happy_var_1) -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn12 - ([(happy_var_1,happy_var_3)] - )}} - -happyReduce_31 = happyReduce 5# 6# happyReduction_31 -happyReduction_31 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokenName happy_var_1) -> - case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOut12 happy_x_5 of { happy_var_5 -> - happyIn12 - ((happy_var_1,happy_var_3):happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_32 = happySpecReduce_1 7# happyReduction_32 -happyReduction_32 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenName happy_var_1) -> - happyIn13 - (R happy_var_1 - )} - -happyReduce_33 = happySpecReduce_3 7# happyReduction_33 -happyReduction_33 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn13 - (happy_var_2 - )} - -happyReduce_34 = happyReduce 4# 7# happyReduction_34 -happyReduction_34 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn13 - (App happy_var_1 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_35 = happySpecReduce_3 7# happyReduction_35 -happyReduction_35 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn13 - (Con 0 happy_var_2 - )} - -happyReduce_36 = happyReduce 4# 7# happyReduction_36 -happyReduction_36 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn13 - (Lazy happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_37 = happyReduce 4# 7# happyReduction_37 -happyReduction_37 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn13 - (Effect happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_38 = happyReduce 5# 7# happyReduction_38 -happyReduction_38 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenInt happy_var_2) -> - case happyOut19 happy_x_4 of { happy_var_4 -> - happyIn13 - (Con happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_39 = happySpecReduce_1 7# happyReduction_39 -happyReduction_39 happy_x_1 - = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn13 - (Const happy_var_1 - )} - -happyReduce_40 = happySpecReduce_3 7# happyReduction_40 -happyReduction_40 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_3 of { (TokenInt happy_var_3) -> - happyIn13 - (Proj happy_var_1 happy_var_3 - )}} - -happyReduce_41 = happyReduce 8# 7# happyReduction_41 -happyReduction_41 (happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenName happy_var_2) -> - case happyOut7 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_6 of { happy_var_6 -> - case happyOut13 happy_x_8 of { happy_var_8 -> - happyIn13 - (Let happy_var_2 happy_var_4 happy_var_6 happy_var_8 - ) `HappyStk` happyRest}}}} - -happyReduce_42 = happyReduce 7# 7# happyReduction_42 -happyReduction_42 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (TokenName happy_var_3) -> - case happyOut13 happy_x_5 of { happy_var_5 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn13 - (LetM happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_43 = happyReduce 6# 7# happyReduction_43 -happyReduction_43 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenName happy_var_2) -> - case happyOut7 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_6 of { happy_var_6 -> - happyIn13 - (Lam happy_var_2 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_44 = happySpecReduce_3 7# happyReduction_44 -happyReduction_44 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn13 - (Let (MN "unused" 0) TyUnit happy_var_1 happy_var_3 - )}} - -happyReduce_45 = happyReduce 6# 7# happyReduction_45 -happyReduction_45 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_2 of { happy_var_2 -> - case happyOut13 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_6 of { happy_var_6 -> - happyIn13 - (If happy_var_2 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_46 = happyReduce 6# 7# happyReduction_46 -happyReduction_46 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - case happyOut13 happy_x_5 of { happy_var_5 -> - happyIn13 - (While happy_var_3 happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_47 = happyReduce 8# 7# happyReduction_47 -happyReduction_47 (happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - case happyOut13 happy_x_5 of { happy_var_5 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn13 - (WhileAcc happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_48 = happyReduce 8# 7# happyReduction_48 -happyReduction_48 (happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut14 happy_x_3 of { happy_var_3 -> - case happyOut13 happy_x_5 of { happy_var_5 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn13 - (WithMem happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_49 = happySpecReduce_1 7# happyReduction_49 -happyReduction_49 happy_x_1 - = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn13 - (happy_var_1 - )} - -happyReduce_50 = happySpecReduce_1 7# happyReduction_50 -happyReduction_50 happy_x_1 - = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn13 - (happy_var_1 - )} - -happyReduce_51 = happySpecReduce_2 7# happyReduction_51 -happyReduction_51 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn13 - (Error happy_var_2 - )} - -happyReduce_52 = happySpecReduce_1 7# happyReduction_52 -happyReduction_52 happy_x_1 - = happyIn13 - (Impossible - ) - -happyReduce_53 = happyReduce 6# 7# happyReduction_53 -happyReduction_53 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut7 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokenString happy_var_3) -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn13 - (ForeignCall happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_54 = happyReduce 7# 7# happyReduction_54 -happyReduction_54 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokenString happy_var_4) -> - case happyOut20 happy_x_6 of { happy_var_6 -> - happyIn13 - (LazyForeignCall happy_var_3 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_55 = happySpecReduce_1 8# happyReduction_55 -happyReduction_55 happy_x_1 - = happyIn14 - (FixedPool - ) - -happyReduce_56 = happySpecReduce_1 8# happyReduction_56 -happyReduction_56 happy_x_1 - = happyIn14 - (GrowablePool - ) - -happyReduce_57 = happyReduce 6# 9# happyReduction_57 -happyReduction_57 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_2 of { happy_var_2 -> - case happyOut16 happy_x_5 of { happy_var_5 -> - happyIn15 - (Case happy_var_2 happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_58 = happySpecReduce_0 10# happyReduction_58 -happyReduction_58 = happyIn16 - ([] - ) - -happyReduce_59 = happySpecReduce_1 10# happyReduction_59 -happyReduction_59 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn16 - ([happy_var_1] - )} - -happyReduce_60 = happySpecReduce_3 10# happyReduction_60 -happyReduction_60 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - case happyOut16 happy_x_3 of { happy_var_3 -> - happyIn16 - (happy_var_1:happy_var_3 - )}} - -happyReduce_61 = happyReduce 7# 11# happyReduction_61 -happyReduction_61 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenInt happy_var_2) -> - case happyOut12 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn17 - (Alt happy_var_2 happy_var_4 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_62 = happySpecReduce_3 11# happyReduction_62 -happyReduction_62 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokenInt happy_var_1) -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn17 - (ConstAlt happy_var_1 happy_var_3 - )}} - -happyReduce_63 = happySpecReduce_3 11# happyReduction_63 -happyReduction_63 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn17 - (DefaultCase happy_var_3 - )} - -happyReduce_64 = happySpecReduce_3 12# happyReduction_64 -happyReduction_64 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Plus happy_var_1 happy_var_3 - )}} - -happyReduce_65 = happySpecReduce_3 12# happyReduction_65 -happyReduction_65 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Minus happy_var_1 happy_var_3 - )}} - -happyReduce_66 = happySpecReduce_2 12# happyReduction_66 -happyReduction_66 happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn18 - (Op Minus (Const (MkInt 0)) happy_var_2 - )} - -happyReduce_67 = happySpecReduce_3 12# happyReduction_67 -happyReduction_67 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Times happy_var_1 happy_var_3 - )}} - -happyReduce_68 = happySpecReduce_3 12# happyReduction_68 -happyReduction_68 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Divide happy_var_1 happy_var_3 - )}} - -happyReduce_69 = happySpecReduce_3 12# happyReduction_69 -happyReduction_69 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Modulo happy_var_1 happy_var_3 - )}} - -happyReduce_70 = happySpecReduce_3 12# happyReduction_70 -happyReduction_70 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FPlus happy_var_1 happy_var_3 - )}} - -happyReduce_71 = happySpecReduce_3 12# happyReduction_71 -happyReduction_71 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FMinus happy_var_1 happy_var_3 - )}} - -happyReduce_72 = happySpecReduce_2 12# happyReduction_72 -happyReduction_72 happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn18 - (Op FMinus (Const (MkInt 0)) happy_var_2 - )} - -happyReduce_73 = happySpecReduce_3 12# happyReduction_73 -happyReduction_73 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FTimes happy_var_1 happy_var_3 - )}} - -happyReduce_74 = happySpecReduce_3 12# happyReduction_74 -happyReduction_74 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FDivide happy_var_1 happy_var_3 - )}} - -happyReduce_75 = happySpecReduce_3 12# happyReduction_75 -happyReduction_75 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op ShL happy_var_1 happy_var_3 - )}} - -happyReduce_76 = happySpecReduce_3 12# happyReduction_76 -happyReduction_76 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op ShR happy_var_1 happy_var_3 - )}} - -happyReduce_77 = happySpecReduce_3 12# happyReduction_77 -happyReduction_77 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpLT happy_var_1 happy_var_3 - )}} - -happyReduce_78 = happySpecReduce_3 12# happyReduction_78 -happyReduction_78 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpGT happy_var_1 happy_var_3 - )}} - -happyReduce_79 = happySpecReduce_3 12# happyReduction_79 -happyReduction_79 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpLE happy_var_1 happy_var_3 - )}} - -happyReduce_80 = happySpecReduce_3 12# happyReduction_80 -happyReduction_80 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpGE happy_var_1 happy_var_3 - )}} - -happyReduce_81 = happySpecReduce_3 12# happyReduction_81 -happyReduction_81 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpEQ happy_var_1 happy_var_3 - )}} - -happyReduce_82 = happySpecReduce_3 12# happyReduction_82 -happyReduction_82 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFLT happy_var_1 happy_var_3 - )}} - -happyReduce_83 = happySpecReduce_3 12# happyReduction_83 -happyReduction_83 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFGT happy_var_1 happy_var_3 - )}} - -happyReduce_84 = happySpecReduce_3 12# happyReduction_84 -happyReduction_84 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFLE happy_var_1 happy_var_3 - )}} - -happyReduce_85 = happySpecReduce_3 12# happyReduction_85 -happyReduction_85 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFGE happy_var_1 happy_var_3 - )}} - -happyReduce_86 = happySpecReduce_3 12# happyReduction_86 -happyReduction_86 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFEQ happy_var_1 happy_var_3 - )}} - -happyReduce_87 = happySpecReduce_0 13# happyReduction_87 -happyReduction_87 = happyIn19 - ([] - ) - -happyReduce_88 = happySpecReduce_1 13# happyReduction_88 -happyReduction_88 happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - happyIn19 - ([happy_var_1] - )} - -happyReduce_89 = happySpecReduce_3 13# happyReduction_89 -happyReduction_89 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn19 - (happy_var_1:happy_var_3 - )}} - -happyReduce_90 = happySpecReduce_0 14# happyReduction_90 -happyReduction_90 = happyIn20 - ([] - ) - -happyReduce_91 = happySpecReduce_3 14# happyReduction_91 -happyReduction_91 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn20 - ([(happy_var_1,happy_var_3)] - )}} - -happyReduce_92 = happyReduce 5# 14# happyReduction_92 -happyReduction_92 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn20 - ((happy_var_1,happy_var_3):happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_93 = happySpecReduce_1 15# happyReduction_93 -happyReduction_93 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenInt happy_var_1) -> - happyIn21 - (MkInt happy_var_1 - )} - -happyReduce_94 = happySpecReduce_1 15# happyReduction_94 -happyReduction_94 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenBigInt happy_var_1) -> - happyIn21 - (MkBigInt happy_var_1 - )} - -happyReduce_95 = happySpecReduce_1 15# happyReduction_95 -happyReduction_95 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenChar happy_var_1) -> - happyIn21 - (MkChar happy_var_1 - )} - -happyReduce_96 = happySpecReduce_1 15# happyReduction_96 -happyReduction_96 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenBool happy_var_1) -> - happyIn21 - (MkBool happy_var_1 - )} - -happyReduce_97 = happySpecReduce_1 15# happyReduction_97 -happyReduction_97 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenFloat happy_var_1) -> - happyIn21 - (MkFloat happy_var_1 - )} - -happyReduce_98 = happySpecReduce_1 15# happyReduction_98 -happyReduction_98 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenBigFloat happy_var_1) -> - happyIn21 - (MkBigFloat happy_var_1 - )} - -happyReduce_99 = happySpecReduce_1 15# happyReduction_99 -happyReduction_99 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenString happy_var_1) -> - happyIn21 - (MkString happy_var_1 - )} - -happyReduce_100 = happySpecReduce_1 15# happyReduction_100 -happyReduction_100 happy_x_1 - = happyIn21 - (MkUnit - ) - -happyReduce_101 = happySpecReduce_1 15# happyReduction_101 -happyReduction_101 happy_x_1 - = happyIn21 - (MkUnused - ) - -happyReduce_102 = happyMonadReduce 0# 16# happyReduction_102 -happyReduction_102 (happyRest) tk - = happyThen (( getLineNo) - ) (\r -> happyReturn (happyIn22 r)) - -happyReduce_103 = happyMonadReduce 0# 17# happyReduction_103 -happyReduction_103 (happyRest) tk - = happyThen (( getFileName) - ) (\r -> happyReturn (happyIn23 r)) - -happyNewToken action sts stk - = lexer(\tk -> - let cont i = happyDoAction i tk action sts stk in - case tk of { - TokenEOF -> happyDoAction 85# tk action sts stk; - TokenName happy_dollar_dollar -> cont 1#; - TokenString happy_dollar_dollar -> cont 2#; - TokenInt happy_dollar_dollar -> cont 3#; - TokenBigInt happy_dollar_dollar -> cont 4#; - TokenBool happy_dollar_dollar -> cont 5#; - TokenFloat happy_dollar_dollar -> cont 6#; - TokenBigFloat happy_dollar_dollar -> cont 7#; - TokenChar happy_dollar_dollar -> cont 8#; - TokenIntType -> cont 9#; - TokenBigIntType -> cont 10#; - TokenCharType -> cont 11#; - TokenBoolType -> cont 12#; - TokenFloatType -> cont 13#; - TokenBigFloatType -> cont 14#; - TokenStringType -> cont 15#; - TokenPtrType -> cont 16#; - TokenUnitType -> cont 17#; - TokenFunType -> cont 18#; - TokenDataType -> cont 19#; - TokenTyCType -> cont 20#; - TokenAnyType -> cont 21#; - TokenUnit -> cont 22#; - TokenCon -> cont 23#; - TokenDefault -> cont 24#; - TokenLet -> cont 25#; - TokenCase -> cont 26#; - TokenOf -> cont 27#; - TokenIf -> cont 28#; - TokenThen -> cont 29#; - TokenElse -> cont 30#; - TokenWhile -> cont 31#; - TokenMemory -> cont 32#; - TokenFixed -> cont 33#; - TokenGrowable -> cont 34#; - TokenUnused -> cont 35#; - TokenIn -> cont 36#; - TokenLazy -> cont 37#; - TokenStrict -> cont 38#; - TokenEffect -> cont 39#; - TokenForeign -> cont 40#; - TokenError -> cont 41#; - TokenImpossible -> cont 42#; - TokenOB -> cont 43#; - TokenCB -> cont 44#; - TokenOCB -> cont 45#; - TokenCCB -> cont 46#; - TokenOSB -> cont 47#; - TokenCSB -> cont 48#; - TokenPlus -> cont 49#; - TokenMinus -> cont 50#; - TokenTimes -> cont 51#; - TokenDivide -> cont 52#; - TokenMod -> cont 53#; - TokenFPlus -> cont 54#; - TokenFMinus -> cont 55#; - TokenFTimes -> cont 56#; - TokenFDivide -> cont 57#; - TokenEquals -> cont 58#; - TokenEQ -> cont 59#; - TokenLE -> cont 60#; - TokenGE -> cont 61#; - TokenFEQ -> cont 62#; - TokenFLE -> cont 63#; - TokenFGE -> cont 64#; - TokenShL -> cont 65#; - TokenShR -> cont 66#; - TokenLT -> cont 67#; - TokenGT -> cont 68#; - TokenFLT -> cont 69#; - TokenFGT -> cont 70#; - TokenColon -> cont 71#; - TokenProj -> cont 72#; - TokenSemi -> cont 73#; - TokenComma -> cont 74#; - TokenBar -> cont 75#; - TokenDot -> cont 76#; - TokenLam -> cont 77#; - TokenArrow -> cont 78#; - TokenCInclude -> cont 79#; - TokenExtern -> cont 80#; - TokenExport -> cont 81#; - TokenCType -> cont 82#; - TokenInclude -> cont 83#; - TokenInline -> cont 84#; - _ -> happyError' tk - }) - -happyError_ tk = happyError' tk - -happyThen :: () => P a -> (a -> P b) -> P b -happyThen = (thenP) -happyReturn :: () => a -> P a -happyReturn = (returnP) -happyThen1 = happyThen -happyReturn1 :: () => a -> P a -happyReturn1 = happyReturn -happyError' :: () => (Token) -> P a -happyError' tk = (\token -> happyError) tk - -mkparse = happySomeParser where - happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut6 x)) - -mkexpr = happySomeParser where - happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut13 x)) - -mkdecl = happySomeParser where - happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut8 x)) - -happySeq = happyDontSeq - - -mkBind :: Name -> [Type] -> Type -> [Name] -> Expr -> Maybe String -> [CGFlag] -> Decl -mkBind n tys ret ns expr export fl = Decl n ret (Bind (zip ns tys) 0 expr fl) export fl - -mkExtern :: Name -> [Type] -> Type -> [Name] -> Decl -mkExtern n tys ret ns = Extern n ret tys - -parse :: String -> FilePath -> Result [Decl] -parse s fn = mkparse s fn 1 - -parseExpr :: String -> Result Expr -parseExpr s = mkexpr s "[expr]" 1 - -parseDecl :: String -> Result Decl -parseDecl s = mkdecl s "[decl]" 1 - -parseFile :: FilePath -> IO (Result [Decl]) -parseFile fn = do s <- readFile fn - let x = parse s fn - return x -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} --- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp - -{-# LINE 30 "templates/GenericTemplate.hs" #-} - - -data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList - - - - - -{-# LINE 51 "templates/GenericTemplate.hs" #-} - -{-# LINE 61 "templates/GenericTemplate.hs" #-} - -{-# LINE 70 "templates/GenericTemplate.hs" #-} - -infixr 9 `HappyStk` -data HappyStk a = HappyStk a (HappyStk a) - ------------------------------------------------------------------------------ --- starting the parse - -happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll - ------------------------------------------------------------------------------ --- Accepting the parse - --- If the current token is 0#, it means we've just accepted a partial --- parse (a %partial parser). We must ignore the saved token on the top of --- the stack in this case. -happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = - happyReturn1 ans -happyAccept j tk st sts (HappyStk ans _) = - (happyTcHack j (happyTcHack st)) (happyReturn1 ans) - ------------------------------------------------------------------------------ --- Arrays only: do the next action - - - -happyDoAction i tk st - = {- nothing -} - - - case action of - 0# -> {- nothing -} - happyFail i tk st - -1# -> {- nothing -} - happyAccept i tk st - n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} - - (happyReduceArr Happy_Data_Array.! rule) i tk st - where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) - n -> {- nothing -} - - - happyShift new_state i tk st - where !(new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) - where !(off) = indexShortOffAddr happyActOffsets st - !(off_i) = (off Happy_GHC_Exts.+# i) - check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#)) - then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i) - else False - !(action) - | check = indexShortOffAddr happyTable off_i - | otherwise = indexShortOffAddr happyDefActions st - -{-# LINE 130 "templates/GenericTemplate.hs" #-} - - -indexShortOffAddr (HappyA# arr) off = - Happy_GHC_Exts.narrow16Int# i - where - !i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) - !high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) - !low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) - !off' = off Happy_GHC_Exts.*# 2# - - - - - -data HappyAddr = HappyA# Happy_GHC_Exts.Addr# - - - - ------------------------------------------------------------------------------ --- HappyState data type (not arrays) - -{-# LINE 163 "templates/GenericTemplate.hs" #-} - ------------------------------------------------------------------------------ --- Shifting a token - -happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = - let !(i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in --- trace "shifting the error token" $ - happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) - -happyShift new_state i tk st sts stk = - happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) - --- happyReduce is specialised for the common cases. - -happySpecReduce_0 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_0 nt fn j tk st@((action)) sts stk - = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) - -happySpecReduce_1 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') - = let r = fn v1 in - happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) - -happySpecReduce_2 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') - = let r = fn v1 v2 in - happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) - -happySpecReduce_3 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') - = let r = fn v1 v2 v3 in - happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) - -happyReduce k i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happyReduce k nt fn j tk st sts stk - = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of - sts1@((HappyCons (st1@(action)) (_))) -> - let r = fn stk in -- it doesn't hurt to always seq here... - happyDoSeq r (happyGoto nt j tk st1 sts1 r) - -happyMonadReduce k nt fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happyMonadReduce k nt fn j tk st sts stk = - happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) - where !(sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts)) - drop_stk = happyDropStk k stk - -happyMonad2Reduce k nt fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happyMonad2Reduce k nt fn j tk st sts stk = - happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) - where !(sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts)) - drop_stk = happyDropStk k stk - - !(off) = indexShortOffAddr happyGotoOffsets st1 - !(off_i) = (off Happy_GHC_Exts.+# nt) - !(new_state) = indexShortOffAddr happyTable off_i - - - - -happyDrop 0# l = l -happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t - -happyDropStk 0# l = l -happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs - ------------------------------------------------------------------------------ --- Moving to a new state after a reduction - - -happyGoto nt j tk st = - {- nothing -} - happyDoAction j tk new_state - where !(off) = indexShortOffAddr happyGotoOffsets st - !(off_i) = (off Happy_GHC_Exts.+# nt) - !(new_state) = indexShortOffAddr happyTable off_i - - - - ------------------------------------------------------------------------------ --- Error recovery (0# is the error token) - --- parse error if we are in recovery and we fail again -happyFail 0# tk old_st _ stk = --- trace "failing" $ - happyError_ tk - -{- We don't need state discarding for our restricted implementation of - "error". In fact, it can cause some bogus parses, so I've disabled it - for now --SDM - --- discard a state -happyFail 0# tk old_st (HappyCons ((action)) (sts)) - (saved_tok `HappyStk` _ `HappyStk` stk) = --- trace ("discarding state, depth " ++ show (length stk)) $ - happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk)) --} - --- Enter error recovery: generate an error token, --- save the old token and carry on. -happyFail i tk (action) sts stk = --- trace "entering error recovery" $ - happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) - --- Internal happy errors: - -notHappyAtAll = error "Internal Happy error\n" - ------------------------------------------------------------------------------ --- Hack to get the typechecker to accept our action functions - - -happyTcHack :: Happy_GHC_Exts.Int# -> a -> a -happyTcHack x y = y -{-# INLINE happyTcHack #-} - - ------------------------------------------------------------------------------ --- Seq-ing. If the --strict flag is given, then Happy emits --- happySeq = happyDoSeq --- otherwise it emits --- happySeq = happyDontSeq - -happyDoSeq, happyDontSeq :: a -> b -> b -happyDoSeq a b = a `seq` b -happyDontSeq a b = b - ------------------------------------------------------------------------------ --- Don't inline any functions from the template. GHC has a nasty habit --- of deciding to inline happyGoto everywhere, which increases the size of --- the generated parser quite a bit. - - -{-# NOINLINE happyDoAction #-} -{-# NOINLINE happyTable #-} -{-# NOINLINE happyCheck #-} -{-# NOINLINE happyActOffsets #-} -{-# NOINLINE happyGotoOffsets #-} -{-# NOINLINE happyDefActions #-} - -{-# NOINLINE happyShift #-} -{-# NOINLINE happySpecReduce_0 #-} -{-# NOINLINE happySpecReduce_1 #-} -{-# NOINLINE happySpecReduce_2 #-} -{-# NOINLINE happySpecReduce_3 #-} -{-# NOINLINE happyReduce #-} -{-# NOINLINE happyMonadReduce #-} -{-# NOINLINE happyGoto #-} -{-# NOINLINE happyFail #-} - --- end of Happy Template. diff --git a/dist/build/Epic/epic-tmp/Epic/Parser.hs b/dist/build/Epic/epic-tmp/Epic/Parser.hs deleted file mode 100644 --- a/dist/build/Epic/epic-tmp/Epic/Parser.hs +++ /dev/null @@ -1,1587 +0,0 @@ -{-# OPTIONS_GHC -fno-warn-overlapping-patterns #-} -{-# OPTIONS -fglasgow-exts -cpp #-} --- -*-Haskell-*- -{-# OPTIONS_GHC -fglasgow-exts #-} - -module Epic.Parser where - -import Char -import System.IO.Unsafe - -import Epic.Language -import Epic.Lexer -import qualified Data.Array as Happy_Data_Array -import qualified GHC.Exts as Happy_GHC_Exts - --- parser produced by Happy Version 1.18.5 - -newtype HappyAbsSyn = HappyAbsSyn HappyAny -#if __GLASGOW_HASKELL__ >= 607 -type HappyAny = Happy_GHC_Exts.Any -#else -type HappyAny = forall a . a -#endif -happyIn6 :: ([Decl]) -> (HappyAbsSyn ) -happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn6 #-} -happyOut6 :: (HappyAbsSyn ) -> ([Decl]) -happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut6 #-} -happyIn7 :: (Type) -> (HappyAbsSyn ) -happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn7 #-} -happyOut7 :: (HappyAbsSyn ) -> (Type) -happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut7 #-} -happyIn8 :: (Decl) -> (HappyAbsSyn ) -happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn8 #-} -happyOut8 :: (HappyAbsSyn ) -> (Decl) -happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut8 #-} -happyIn9 :: ([CGFlag]) -> (HappyAbsSyn ) -happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn9 #-} -happyOut9 :: (HappyAbsSyn ) -> ([CGFlag]) -happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut9 #-} -happyIn10 :: (CGFlag) -> (HappyAbsSyn ) -happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn10 #-} -happyOut10 :: (HappyAbsSyn ) -> (CGFlag) -happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut10 #-} -happyIn11 :: (Maybe String) -> (HappyAbsSyn ) -happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn ) -> (Maybe String) -happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut11 #-} -happyIn12 :: ([(Name,Type)]) -> (HappyAbsSyn ) -happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn ) -> ([(Name,Type)]) -happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut12 #-} -happyIn13 :: (Expr) -> (HappyAbsSyn ) -happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn ) -> (Expr) -happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut13 #-} -happyIn14 :: (Allocator) -> (HappyAbsSyn ) -happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn ) -> (Allocator) -happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut14 #-} -happyIn15 :: (Expr) -> (HappyAbsSyn ) -happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn ) -> (Expr) -happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut15 #-} -happyIn16 :: ([CaseAlt]) -> (HappyAbsSyn ) -happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn ) -> ([CaseAlt]) -happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut16 #-} -happyIn17 :: (CaseAlt) -> (HappyAbsSyn ) -happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn ) -> (CaseAlt) -happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut17 #-} -happyIn18 :: (Expr) -> (HappyAbsSyn ) -happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn ) -> (Expr) -happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut18 #-} -happyIn19 :: ([Expr]) -> (HappyAbsSyn ) -happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn19 #-} -happyOut19 :: (HappyAbsSyn ) -> ([Expr]) -happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut19 #-} -happyIn20 :: ([(Expr,Type)]) -> (HappyAbsSyn ) -happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn ) -> ([(Expr,Type)]) -happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut20 #-} -happyIn21 :: (Const) -> (HappyAbsSyn ) -happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn21 #-} -happyOut21 :: (HappyAbsSyn ) -> (Const) -happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut21 #-} -happyIn22 :: (LineNumber) -> (HappyAbsSyn ) -happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn ) -> (LineNumber) -happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut22 #-} -happyIn23 :: (String) -> (HappyAbsSyn ) -happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn ) -> (String) -happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut23 #-} -happyInTok :: (Token) -> (HappyAbsSyn ) -happyInTok x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyInTok #-} -happyOutTok :: (HappyAbsSyn ) -> (Token) -happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOutTok #-} - - -happyActOffsets :: HappyAddr -happyActOffsets = HappyA# "\x67\x03\x01\x00\x29\x00\x29\x00\x00\x00\xdb\xff\x3f\x02\x25\x02\x23\x02\x22\x02\xca\x01\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x09\x00\x01\x00\x01\x00\xdd\x01\xdc\x01\x00\x00\x25\x00\xdb\x01\x34\x00\x03\x02\x00\x00\x01\x00\x01\x00\x01\x00\x01\x00\xff\x01\x75\x01\x52\x02\xf1\x01\x67\x03\x00\x00\xa2\x01\xe6\xff\xe6\xff\x3f\x01\xb8\x01\xf7\x01\x00\x00\xe5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x01\x00\x00\x01\x00\x34\x00\x01\x00\xf7\x00\x01\x00\x4b\x00\x21\x00\x8d\x01\xc8\x01\x9d\x01\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\xb5\x01\x01\x00\x00\x00\x00\x00\x83\x01\x00\x00\xac\x01\xdb\xff\x00\x00\x00\x00\x00\x00\x81\x01\xaa\x01\x4b\x02\x00\x00\x67\x02\x67\x02\x67\x02\x67\x02\x7f\x02\x7f\x02\x67\x02\x67\x02\x2f\x02\x67\x02\x67\x02\x2f\x02\xe6\xff\xe6\xff\x02\x00\x02\x00\xe6\xff\xe6\xff\xe6\xff\x02\x00\x02\x00\x6d\x01\x01\x00\x6c\x01\x34\x00\x62\x01\x01\x00\x23\x01\x44\x01\x00\x00\x00\x00\xd8\x01\x8b\x01\xb9\x01\x00\x00\x61\x01\x00\x00\x00\x00\x01\x00\x34\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x01\x00\x00\x00\x4e\x01\x00\x00\x01\x00\x01\x00\x67\x00\x0b\x00\x35\x01\x01\x00\x42\x01\x00\x00\x31\x01\x0c\x01\x51\x01\x0b\x01\x34\x00\xd7\x00\x00\x00\xcc\x00\x01\x00\x08\x01\xf6\x00\xcd\x00\x17\x01\xc5\x00\x01\x00\xeb\x00\x07\x01\x01\x00\x9a\x01\xda\x00\x01\x00\x13\x02\x00\x00\x34\x00\xd0\x00\x01\x00\x00\x00\x01\x00\x13\x02\x01\x00\xcf\x00\x01\x00\x0b\x00\x00\x00\xa9\x00\x01\x00\x34\x00\xac\x00\xa6\x00\x34\x00\xe2\x00\x00\x00\x13\x02\x01\x00\x00\x00\x13\x02\xe2\x00\x13\x02\x7e\x01\x5f\x01\x00\x00\x8f\x00\x01\x00\x00\x00\x00\x00\xab\x00\x13\x02\x00\x00\x95\x00\x01\x00\x7c\x00\x00\x00\x01\x00\x13\x02\x13\x02\x00\x00"# - -happyGotoOffsets :: HappyAddr -happyGotoOffsets = HappyA# "\xb0\x03\x9e\x03\x2f\x00\x0a\x00\x00\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x03\x94\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x8b\x03\xb9\x02\x8a\x03\x81\x03\x00\x00\x00\x00\xac\x03\x00\x00\xa6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\xb2\x00\x77\x03\x99\x00\x76\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x02\x6d\x03\x6c\x03\x63\x03\x62\x03\x59\x03\x58\x03\x4f\x03\x4e\x03\x45\x03\x44\x03\x3b\x03\x3a\x03\x31\x03\x30\x03\x27\x03\x26\x03\x1d\x03\x1c\x03\x13\x03\x12\x03\x09\x03\x00\x00\x08\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x6d\x00\x00\x00\xff\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x5a\x00\x5b\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x00\x00\x00\x00\xfe\x02\xf5\x02\x00\x00\x8b\x00\x00\x00\xf4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\xeb\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x02\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\xe1\x02\x00\x00\x00\x00\x38\x00\x00\x00\xe0\x02\x00\x00\xd7\x02\x00\x00\xd6\x02\x00\x00\xcd\x02\x14\x00\x00\x00\x00\x00\xcc\x02\x31\x00\x00\x00\x00\x00\x26\x00\x1f\x00\x00\x00\x00\x00\xc3\x02\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x02\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00"# - -happyDefActions :: HappyAddr -happyDefActions = HappyA# "\xe4\xff\x00\x00\xe4\xff\x00\x00\x00\x00\xe8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\xff\xcd\xff\xd8\xff\xdf\xff\x9c\xff\xa2\xff\xa1\xff\x9f\xff\x9e\xff\x9d\xff\xa0\xff\x9b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\xff\x00\x00\x00\x00\x00\x00\x00\x00\xcb\xff\x00\x00\xa8\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xff\x00\x00\xe4\xff\xfb\xff\x00\x00\xb7\xff\xbd\xff\xa7\xff\x00\x00\x00\x00\xcc\xff\x00\x00\xf9\xff\xf8\xff\xf7\xff\xf6\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xed\xff\xef\xff\x00\x00\xf0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\xff\xe3\xff\x00\x00\xea\xff\x00\x00\xe8\xff\xe5\xff\xe6\xff\xe7\xff\x00\x00\xe2\xff\xd3\xff\xd7\xff\xac\xff\xad\xff\xb1\xff\xb2\xff\xb3\xff\xb4\xff\xaa\xff\xab\xff\xa9\xff\xaf\xff\xb0\xff\xae\xff\xb5\xff\xb6\xff\xb8\xff\xb9\xff\xba\xff\xbb\xff\xbc\xff\xbe\xff\xbf\xff\x00\x00\xa8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\xc7\xff\x00\x00\x00\x00\x00\x00\xee\xff\x00\x00\xde\xff\xdc\xff\xa8\xff\x00\x00\x98\xff\xfa\xff\x00\x00\xa6\xff\xa5\xff\xda\xff\x00\x00\xdb\xff\x00\x00\x00\x00\x00\x00\xc5\xff\x00\x00\x00\x00\x00\x00\xdd\xff\x00\x00\x00\x00\xe2\xff\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x00\x00\x00\x00\xc4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\xff\x00\x00\x00\x00\x00\x00\xd4\xff\xca\xff\x00\x00\x00\x00\x00\x00\xd1\xff\x00\x00\xd2\xff\x00\x00\x00\x00\x00\x00\xc5\xff\xc6\xff\x00\x00\x00\x00\x00\x00\xe1\xff\x00\x00\x00\x00\xe2\xff\xeb\xff\xd5\xff\x00\x00\xc3\xff\xc1\xff\xe2\xff\xc0\xff\x00\x00\x00\x00\xc9\xff\xa4\xff\xa5\xff\xcf\xff\xd0\xff\x00\x00\xd6\xff\xe0\xff\x00\x00\x00\x00\x00\x00\xa3\xff\x00\x00\xec\xff\xc2\xff"# - -happyCheck :: HappyAddr -happyCheck = HappyA# "\xff\xff\x26\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x01\x00\x07\x00\x02\x00\x09\x00\x03\x00\x05\x00\x0c\x00\x2b\x00\x0e\x00\x0f\x00\x07\x00\x06\x00\x09\x00\x16\x00\x17\x00\x0c\x00\x19\x00\x1a\x00\x0f\x00\x1c\x00\x0a\x00\x0b\x00\x1f\x00\x20\x00\x17\x00\x18\x00\x23\x00\x06\x00\x25\x00\x01\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2b\x00\x48\x00\x54\x00\x2f\x00\x02\x00\x01\x00\x32\x00\x05\x00\x33\x00\x34\x00\x35\x00\x37\x00\x01\x00\x38\x00\x39\x00\x1b\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x48\x00\x01\x00\x2b\x00\x28\x00\x4d\x00\x06\x00\x2b\x00\x48\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x1d\x00\x48\x00\x49\x00\x07\x00\x11\x00\x09\x00\x01\x00\x07\x00\x0c\x00\x09\x00\x0e\x00\x0f\x00\x0c\x00\x0d\x00\x2b\x00\x0f\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x1e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x0a\x00\x0b\x00\x06\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x08\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x03\x00\x04\x00\x01\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x4e\x00\x48\x00\x49\x00\x24\x00\x07\x00\x3a\x00\x09\x00\x03\x00\x04\x00\x0c\x00\x2b\x00\x0e\x00\x0f\x00\x2c\x00\x55\x00\x4a\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x24\x00\x48\x00\x49\x00\x07\x00\x4e\x00\x09\x00\x4a\x00\x2b\x00\x0c\x00\x0d\x00\x2b\x00\x0f\x00\x2c\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x4e\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x21\x00\x22\x00\x03\x00\x4e\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x4e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x4a\x00\x2e\x00\x2c\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x4b\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x4a\x00\x01\x00\x47\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x4a\x00\x2c\x00\x3a\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2b\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x4c\x00\x48\x00\x49\x00\x4a\x00\x2b\x00\x2c\x00\x2b\x00\x02\x00\x4a\x00\x2d\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x3a\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x01\x00\x2b\x00\x01\x00\x2b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x03\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x2b\x00\x01\x00\x55\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x47\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x02\x00\x02\x00\x30\x00\x47\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x02\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x01\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x02\x00\x2b\x00\x2b\x00\x2b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x03\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x55\x00\x48\x00\x49\x00\x2b\x00\x2c\x00\x02\x00\x02\x00\x01\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x41\x00\x42\x00\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x07\x00\xff\xff\x09\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x07\x00\x0f\x00\x09\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x48\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x07\x00\x09\x00\x09\x00\xff\xff\x0c\x00\x0c\x00\xff\xff\x0f\x00\x0f\x00\x07\x00\x00\x00\x09\x00\x02\x00\xff\xff\x0c\x00\x05\x00\x00\x00\x0f\x00\x02\x00\xff\xff\x00\x00\x05\x00\x02\x00\xff\xff\xff\xff\x05\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# - -happyTable :: HappyAddr -happyTable = HappyA# "\x00\x00\x6c\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x4b\x00\xbc\x00\x04\x00\x0c\x00\xb6\x00\x05\x00\x0d\x00\x4e\x00\xe7\x00\x0e\x00\xea\x00\xe1\x00\x0c\x00\x18\x00\x19\x00\x0d\x00\x1a\x00\x1b\x00\x0e\x00\x1c\x00\xd6\x00\xb4\x00\x1d\x00\x1e\x00\xb7\x00\xb8\x00\x1f\x00\xe3\x00\x20\x00\xe4\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x4e\x00\x64\x00\x6d\x00\x26\x00\x0a\x00\xd3\x00\x27\x00\x05\x00\x51\x00\x52\x00\x53\x00\x28\x00\xdd\x00\x56\x00\x57\x00\x8c\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x64\x00\xcf\x00\x4e\x00\x45\x00\x29\x00\xad\x00\x46\x00\x4c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x9c\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x8d\x00\x64\x00\x65\x00\xbc\x00\x9b\x00\x0c\x00\xa6\x00\x31\x00\x0d\x00\x0c\x00\xc2\x00\x0e\x00\x0d\x00\x9d\x00\x4e\x00\x0e\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xb9\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xb3\x00\xb4\x00\xaa\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x8e\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x6d\x00\x6a\x00\x92\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x35\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xe9\x00\x64\x00\x65\x00\xd6\x00\xbc\x00\xe6\x00\x0c\x00\x69\x00\x6a\x00\x0d\x00\x4e\x00\xbd\x00\x0e\x00\xe7\x00\xff\xff\xdf\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xac\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xce\x00\x64\x00\x65\x00\x31\x00\xd2\x00\x0c\x00\xd3\x00\x4e\x00\x0d\x00\xa8\x00\xd9\x00\x0e\x00\xdd\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xc1\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xc8\x00\x64\x00\x65\x00\x4e\x00\xc5\x00\x90\x00\x91\x00\xc9\x00\xca\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xcf\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xc6\x00\xcc\x00\xd1\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xcb\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xc4\x00\xac\x00\xaf\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xb0\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\xa4\x00\xb1\x00\xb3\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xbc\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xbf\x00\x64\x00\x65\x00\x99\x00\x4e\x00\xe0\x00\x9f\x00\xa1\x00\xa3\x00\xa6\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xaa\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xa8\x00\x64\x00\x65\x00\x4e\x00\xe1\x00\xac\x00\xad\x00\x6f\x00\x70\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x72\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x89\x00\x8a\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x8b\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xc2\x00\x64\x00\x65\x00\x4e\x00\xa0\x00\x95\x00\x96\x00\x98\x00\x9a\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x2d\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x2f\x00\x64\x00\x65\x00\x4e\x00\xa2\x00\x35\x00\x44\x00\x47\x00\x48\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x4d\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x64\x00\x65\x00\x4e\x00\x97\x00\x66\x00\x67\x00\x68\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x69\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x59\x00\x5a\x00\x00\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x65\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x59\x00\x5a\x00\x00\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x4e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x2c\x00\x00\x00\xfc\xff\x5e\x00\x5f\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x31\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x0d\x00\x87\x00\x31\x00\x0e\x00\x0c\x00\x00\x00\x00\x00\x0d\x00\x32\x00\x64\x00\x0e\x00\xe9\x00\xe2\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xd4\x00\xd7\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xd9\x00\xda\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xdb\x00\xbf\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xc6\x00\xcc\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xb1\x00\xb9\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\xba\x00\xa4\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x70\x00\x72\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x73\x00\x74\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x75\x00\x76\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x77\x00\x78\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x79\x00\x7a\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x7b\x00\x7c\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x7d\x00\x7e\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x7f\x00\x80\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x81\x00\x82\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x83\x00\x84\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x85\x00\x86\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x8d\x00\x91\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x93\x00\x2f\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x30\x00\x33\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x48\x00\x49\x00\x0c\x00\x0c\x00\x00\x00\x0d\x00\x0d\x00\x00\x00\x0e\x00\x0e\x00\x0b\x00\x9a\x00\x0c\x00\x2a\x00\x00\x00\x0d\x00\x05\x00\x2d\x00\x0e\x00\x2a\x00\x00\x00\x29\x00\x05\x00\x2a\x00\x00\x00\x00\x00\x05\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyReduceArr = Happy_Data_Array.array (3, 103) [ - (3 , happyReduce_3), - (4 , happyReduce_4), - (5 , happyReduce_5), - (6 , happyReduce_6), - (7 , happyReduce_7), - (8 , happyReduce_8), - (9 , happyReduce_9), - (10 , happyReduce_10), - (11 , happyReduce_11), - (12 , happyReduce_12), - (13 , happyReduce_13), - (14 , happyReduce_14), - (15 , happyReduce_15), - (16 , happyReduce_16), - (17 , happyReduce_17), - (18 , happyReduce_18), - (19 , happyReduce_19), - (20 , happyReduce_20), - (21 , happyReduce_21), - (22 , happyReduce_22), - (23 , happyReduce_23), - (24 , happyReduce_24), - (25 , happyReduce_25), - (26 , happyReduce_26), - (27 , happyReduce_27), - (28 , happyReduce_28), - (29 , happyReduce_29), - (30 , happyReduce_30), - (31 , happyReduce_31), - (32 , happyReduce_32), - (33 , happyReduce_33), - (34 , happyReduce_34), - (35 , happyReduce_35), - (36 , happyReduce_36), - (37 , happyReduce_37), - (38 , happyReduce_38), - (39 , happyReduce_39), - (40 , happyReduce_40), - (41 , happyReduce_41), - (42 , happyReduce_42), - (43 , happyReduce_43), - (44 , happyReduce_44), - (45 , happyReduce_45), - (46 , happyReduce_46), - (47 , happyReduce_47), - (48 , happyReduce_48), - (49 , happyReduce_49), - (50 , happyReduce_50), - (51 , happyReduce_51), - (52 , happyReduce_52), - (53 , happyReduce_53), - (54 , happyReduce_54), - (55 , happyReduce_55), - (56 , happyReduce_56), - (57 , happyReduce_57), - (58 , happyReduce_58), - (59 , happyReduce_59), - (60 , happyReduce_60), - (61 , happyReduce_61), - (62 , happyReduce_62), - (63 , happyReduce_63), - (64 , happyReduce_64), - (65 , happyReduce_65), - (66 , happyReduce_66), - (67 , happyReduce_67), - (68 , happyReduce_68), - (69 , happyReduce_69), - (70 , happyReduce_70), - (71 , happyReduce_71), - (72 , happyReduce_72), - (73 , happyReduce_73), - (74 , happyReduce_74), - (75 , happyReduce_75), - (76 , happyReduce_76), - (77 , happyReduce_77), - (78 , happyReduce_78), - (79 , happyReduce_79), - (80 , happyReduce_80), - (81 , happyReduce_81), - (82 , happyReduce_82), - (83 , happyReduce_83), - (84 , happyReduce_84), - (85 , happyReduce_85), - (86 , happyReduce_86), - (87 , happyReduce_87), - (88 , happyReduce_88), - (89 , happyReduce_89), - (90 , happyReduce_90), - (91 , happyReduce_91), - (92 , happyReduce_92), - (93 , happyReduce_93), - (94 , happyReduce_94), - (95 , happyReduce_95), - (96 , happyReduce_96), - (97 , happyReduce_97), - (98 , happyReduce_98), - (99 , happyReduce_99), - (100 , happyReduce_100), - (101 , happyReduce_101), - (102 , happyReduce_102), - (103 , happyReduce_103) - ] - -happy_n_terms = 86 :: Int -happy_n_nonterms = 18 :: Int - -happyReduce_3 = happySpecReduce_1 0# happyReduction_3 -happyReduction_3 happy_x_1 - = case happyOut8 happy_x_1 of { happy_var_1 -> - happyIn6 - ([happy_var_1] - )} - -happyReduce_4 = happySpecReduce_2 0# happyReduction_4 -happyReduction_4 happy_x_2 - happy_x_1 - = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn6 - (happy_var_1:happy_var_2 - )}} - -happyReduce_5 = happyMonadReduce 4# 0# happyReduction_5 -happyReduction_5 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut23 happy_x_4 of { happy_var_4 -> - ( - let rest = happy_var_3 in - let pt = unsafePerformIO (readFile happy_var_2) in - case (parse pt happy_var_4) of - Success x -> returnP (x ++ rest) - Failure err file ln -> failP err)}}} - ) (\r -> happyReturn (happyIn6 r)) - -happyReduce_6 = happySpecReduce_1 1# happyReduction_6 -happyReduction_6 happy_x_1 - = happyIn7 - (TyInt - ) - -happyReduce_7 = happySpecReduce_1 1# happyReduction_7 -happyReduction_7 happy_x_1 - = happyIn7 - (TyBigInt - ) - -happyReduce_8 = happySpecReduce_1 1# happyReduction_8 -happyReduction_8 happy_x_1 - = happyIn7 - (TyChar - ) - -happyReduce_9 = happySpecReduce_1 1# happyReduction_9 -happyReduction_9 happy_x_1 - = happyIn7 - (TyBool - ) - -happyReduce_10 = happySpecReduce_1 1# happyReduction_10 -happyReduction_10 happy_x_1 - = happyIn7 - (TyFloat - ) - -happyReduce_11 = happySpecReduce_1 1# happyReduction_11 -happyReduction_11 happy_x_1 - = happyIn7 - (TyBigFloat - ) - -happyReduce_12 = happySpecReduce_1 1# happyReduction_12 -happyReduction_12 happy_x_1 - = happyIn7 - (TyString - ) - -happyReduce_13 = happySpecReduce_1 1# happyReduction_13 -happyReduction_13 happy_x_1 - = happyIn7 - (TyPtr - ) - -happyReduce_14 = happySpecReduce_1 1# happyReduction_14 -happyReduction_14 happy_x_1 - = happyIn7 - (TyUnit - ) - -happyReduce_15 = happySpecReduce_1 1# happyReduction_15 -happyReduction_15 happy_x_1 - = happyIn7 - (TyAny - ) - -happyReduce_16 = happySpecReduce_1 1# happyReduction_16 -happyReduction_16 happy_x_1 - = happyIn7 - (TyData - ) - -happyReduce_17 = happySpecReduce_2 1# happyReduction_17 -happyReduction_17 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn7 - (TyCType happy_var_2 - )} - -happyReduce_18 = happySpecReduce_1 1# happyReduction_18 -happyReduction_18 happy_x_1 - = happyIn7 - (TyFun - ) - -happyReduce_19 = happyReduce 10# 2# happyReduction_19 -happyReduction_19 (happy_x_10 `HappyStk` - happy_x_9 `HappyStk` - happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut11 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokenName happy_var_3) -> - case happyOut12 happy_x_5 of { happy_var_5 -> - case happyOut7 happy_x_8 of { happy_var_8 -> - case happyOut13 happy_x_10 of { happy_var_10 -> - happyIn8 - (mkBind happy_var_3 (map snd happy_var_5) happy_var_8 (map fst happy_var_5) happy_var_10 happy_var_1 happy_var_2 - ) `HappyStk` happyRest}}}}}} - -happyReduce_20 = happyReduce 7# 2# happyReduction_20 -happyReduction_20 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenName happy_var_2) -> - case happyOut12 happy_x_4 of { happy_var_4 -> - case happyOut7 happy_x_7 of { happy_var_7 -> - happyIn8 - (mkExtern happy_var_2 (map snd happy_var_4) happy_var_7 (map fst happy_var_4) - ) `HappyStk` happyRest}}} - -happyReduce_21 = happySpecReduce_2 2# happyReduction_21 -happyReduction_21 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn8 - (Include happy_var_2 - )} - -happyReduce_22 = happySpecReduce_2 2# happyReduction_22 -happyReduction_22 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn8 - (CType happy_var_2 - )} - -happyReduce_23 = happySpecReduce_0 3# happyReduction_23 -happyReduction_23 = happyIn9 - ([] - ) - -happyReduce_24 = happySpecReduce_2 3# happyReduction_24 -happyReduction_24 happy_x_2 - happy_x_1 - = case happyOut10 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_2 of { happy_var_2 -> - happyIn9 - (happy_var_1:happy_var_2 - )}} - -happyReduce_25 = happySpecReduce_1 4# happyReduction_25 -happyReduction_25 happy_x_1 - = happyIn10 - (Inline - ) - -happyReduce_26 = happySpecReduce_1 4# happyReduction_26 -happyReduction_26 happy_x_1 - = happyIn10 - (Strict - ) - -happyReduce_27 = happySpecReduce_0 5# happyReduction_27 -happyReduction_27 = happyIn11 - (Nothing - ) - -happyReduce_28 = happySpecReduce_2 5# happyReduction_28 -happyReduction_28 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn11 - (Just happy_var_2 - )} - -happyReduce_29 = happySpecReduce_0 6# happyReduction_29 -happyReduction_29 = happyIn12 - ([] - ) - -happyReduce_30 = happySpecReduce_3 6# happyReduction_30 -happyReduction_30 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokenName happy_var_1) -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn12 - ([(happy_var_1,happy_var_3)] - )}} - -happyReduce_31 = happyReduce 5# 6# happyReduction_31 -happyReduction_31 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokenName happy_var_1) -> - case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOut12 happy_x_5 of { happy_var_5 -> - happyIn12 - ((happy_var_1,happy_var_3):happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_32 = happySpecReduce_1 7# happyReduction_32 -happyReduction_32 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenName happy_var_1) -> - happyIn13 - (R happy_var_1 - )} - -happyReduce_33 = happySpecReduce_3 7# happyReduction_33 -happyReduction_33 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn13 - (happy_var_2 - )} - -happyReduce_34 = happyReduce 4# 7# happyReduction_34 -happyReduction_34 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn13 - (App happy_var_1 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_35 = happySpecReduce_3 7# happyReduction_35 -happyReduction_35 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn13 - (Con 0 happy_var_2 - )} - -happyReduce_36 = happyReduce 4# 7# happyReduction_36 -happyReduction_36 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn13 - (Lazy happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_37 = happyReduce 4# 7# happyReduction_37 -happyReduction_37 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn13 - (Effect happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_38 = happyReduce 5# 7# happyReduction_38 -happyReduction_38 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenInt happy_var_2) -> - case happyOut19 happy_x_4 of { happy_var_4 -> - happyIn13 - (Con happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_39 = happySpecReduce_1 7# happyReduction_39 -happyReduction_39 happy_x_1 - = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn13 - (Const happy_var_1 - )} - -happyReduce_40 = happySpecReduce_3 7# happyReduction_40 -happyReduction_40 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_3 of { (TokenInt happy_var_3) -> - happyIn13 - (Proj happy_var_1 happy_var_3 - )}} - -happyReduce_41 = happyReduce 8# 7# happyReduction_41 -happyReduction_41 (happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenName happy_var_2) -> - case happyOut7 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_6 of { happy_var_6 -> - case happyOut13 happy_x_8 of { happy_var_8 -> - happyIn13 - (Let happy_var_2 happy_var_4 happy_var_6 happy_var_8 - ) `HappyStk` happyRest}}}} - -happyReduce_42 = happyReduce 7# 7# happyReduction_42 -happyReduction_42 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (TokenName happy_var_3) -> - case happyOut13 happy_x_5 of { happy_var_5 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn13 - (LetM happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_43 = happyReduce 6# 7# happyReduction_43 -happyReduction_43 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenName happy_var_2) -> - case happyOut7 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_6 of { happy_var_6 -> - happyIn13 - (Lam happy_var_2 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_44 = happySpecReduce_3 7# happyReduction_44 -happyReduction_44 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn13 - (Let (MN "unused" 0) TyUnit happy_var_1 happy_var_3 - )}} - -happyReduce_45 = happyReduce 6# 7# happyReduction_45 -happyReduction_45 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_2 of { happy_var_2 -> - case happyOut13 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_6 of { happy_var_6 -> - happyIn13 - (If happy_var_2 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_46 = happyReduce 6# 7# happyReduction_46 -happyReduction_46 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - case happyOut13 happy_x_5 of { happy_var_5 -> - happyIn13 - (While happy_var_3 happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_47 = happyReduce 8# 7# happyReduction_47 -happyReduction_47 (happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_3 of { happy_var_3 -> - case happyOut13 happy_x_5 of { happy_var_5 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn13 - (WhileAcc happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_48 = happyReduce 8# 7# happyReduction_48 -happyReduction_48 (happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut14 happy_x_3 of { happy_var_3 -> - case happyOut13 happy_x_5 of { happy_var_5 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn13 - (WithMem happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_49 = happySpecReduce_1 7# happyReduction_49 -happyReduction_49 happy_x_1 - = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn13 - (happy_var_1 - )} - -happyReduce_50 = happySpecReduce_1 7# happyReduction_50 -happyReduction_50 happy_x_1 - = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn13 - (happy_var_1 - )} - -happyReduce_51 = happySpecReduce_2 7# happyReduction_51 -happyReduction_51 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (TokenString happy_var_2) -> - happyIn13 - (Error happy_var_2 - )} - -happyReduce_52 = happySpecReduce_1 7# happyReduction_52 -happyReduction_52 happy_x_1 - = happyIn13 - (Impossible - ) - -happyReduce_53 = happyReduce 6# 7# happyReduction_53 -happyReduction_53 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut7 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokenString happy_var_3) -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn13 - (ForeignCall happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_54 = happyReduce 7# 7# happyReduction_54 -happyReduction_54 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokenString happy_var_4) -> - case happyOut20 happy_x_6 of { happy_var_6 -> - happyIn13 - (LazyForeignCall happy_var_3 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_55 = happySpecReduce_1 8# happyReduction_55 -happyReduction_55 happy_x_1 - = happyIn14 - (FixedPool - ) - -happyReduce_56 = happySpecReduce_1 8# happyReduction_56 -happyReduction_56 happy_x_1 - = happyIn14 - (GrowablePool - ) - -happyReduce_57 = happyReduce 6# 9# happyReduction_57 -happyReduction_57 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_2 of { happy_var_2 -> - case happyOut16 happy_x_5 of { happy_var_5 -> - happyIn15 - (Case happy_var_2 happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_58 = happySpecReduce_0 10# happyReduction_58 -happyReduction_58 = happyIn16 - ([] - ) - -happyReduce_59 = happySpecReduce_1 10# happyReduction_59 -happyReduction_59 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn16 - ([happy_var_1] - )} - -happyReduce_60 = happySpecReduce_3 10# happyReduction_60 -happyReduction_60 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - case happyOut16 happy_x_3 of { happy_var_3 -> - happyIn16 - (happy_var_1:happy_var_3 - )}} - -happyReduce_61 = happyReduce 7# 11# happyReduction_61 -happyReduction_61 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokenInt happy_var_2) -> - case happyOut12 happy_x_4 of { happy_var_4 -> - case happyOut13 happy_x_7 of { happy_var_7 -> - happyIn17 - (Alt happy_var_2 happy_var_4 happy_var_7 - ) `HappyStk` happyRest}}} - -happyReduce_62 = happySpecReduce_3 11# happyReduction_62 -happyReduction_62 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokenInt happy_var_1) -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn17 - (ConstAlt happy_var_1 happy_var_3 - )}} - -happyReduce_63 = happySpecReduce_3 11# happyReduction_63 -happyReduction_63 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn17 - (DefaultCase happy_var_3 - )} - -happyReduce_64 = happySpecReduce_3 12# happyReduction_64 -happyReduction_64 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Plus happy_var_1 happy_var_3 - )}} - -happyReduce_65 = happySpecReduce_3 12# happyReduction_65 -happyReduction_65 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Minus happy_var_1 happy_var_3 - )}} - -happyReduce_66 = happySpecReduce_2 12# happyReduction_66 -happyReduction_66 happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn18 - (Op Minus (Const (MkInt 0)) happy_var_2 - )} - -happyReduce_67 = happySpecReduce_3 12# happyReduction_67 -happyReduction_67 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Times happy_var_1 happy_var_3 - )}} - -happyReduce_68 = happySpecReduce_3 12# happyReduction_68 -happyReduction_68 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Divide happy_var_1 happy_var_3 - )}} - -happyReduce_69 = happySpecReduce_3 12# happyReduction_69 -happyReduction_69 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op Modulo happy_var_1 happy_var_3 - )}} - -happyReduce_70 = happySpecReduce_3 12# happyReduction_70 -happyReduction_70 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FPlus happy_var_1 happy_var_3 - )}} - -happyReduce_71 = happySpecReduce_3 12# happyReduction_71 -happyReduction_71 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FMinus happy_var_1 happy_var_3 - )}} - -happyReduce_72 = happySpecReduce_2 12# happyReduction_72 -happyReduction_72 happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn18 - (Op FMinus (Const (MkInt 0)) happy_var_2 - )} - -happyReduce_73 = happySpecReduce_3 12# happyReduction_73 -happyReduction_73 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FTimes happy_var_1 happy_var_3 - )}} - -happyReduce_74 = happySpecReduce_3 12# happyReduction_74 -happyReduction_74 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op FDivide happy_var_1 happy_var_3 - )}} - -happyReduce_75 = happySpecReduce_3 12# happyReduction_75 -happyReduction_75 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op ShL happy_var_1 happy_var_3 - )}} - -happyReduce_76 = happySpecReduce_3 12# happyReduction_76 -happyReduction_76 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op ShR happy_var_1 happy_var_3 - )}} - -happyReduce_77 = happySpecReduce_3 12# happyReduction_77 -happyReduction_77 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpLT happy_var_1 happy_var_3 - )}} - -happyReduce_78 = happySpecReduce_3 12# happyReduction_78 -happyReduction_78 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpGT happy_var_1 happy_var_3 - )}} - -happyReduce_79 = happySpecReduce_3 12# happyReduction_79 -happyReduction_79 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpLE happy_var_1 happy_var_3 - )}} - -happyReduce_80 = happySpecReduce_3 12# happyReduction_80 -happyReduction_80 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpGE happy_var_1 happy_var_3 - )}} - -happyReduce_81 = happySpecReduce_3 12# happyReduction_81 -happyReduction_81 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpEQ happy_var_1 happy_var_3 - )}} - -happyReduce_82 = happySpecReduce_3 12# happyReduction_82 -happyReduction_82 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFLT happy_var_1 happy_var_3 - )}} - -happyReduce_83 = happySpecReduce_3 12# happyReduction_83 -happyReduction_83 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFGT happy_var_1 happy_var_3 - )}} - -happyReduce_84 = happySpecReduce_3 12# happyReduction_84 -happyReduction_84 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFLE happy_var_1 happy_var_3 - )}} - -happyReduce_85 = happySpecReduce_3 12# happyReduction_85 -happyReduction_85 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFGE happy_var_1 happy_var_3 - )}} - -happyReduce_86 = happySpecReduce_3 12# happyReduction_86 -happyReduction_86 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - happyIn18 - (Op OpFEQ happy_var_1 happy_var_3 - )}} - -happyReduce_87 = happySpecReduce_0 13# happyReduction_87 -happyReduction_87 = happyIn19 - ([] - ) - -happyReduce_88 = happySpecReduce_1 13# happyReduction_88 -happyReduction_88 happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - happyIn19 - ([happy_var_1] - )} - -happyReduce_89 = happySpecReduce_3 13# happyReduction_89 -happyReduction_89 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn19 - (happy_var_1:happy_var_3 - )}} - -happyReduce_90 = happySpecReduce_0 14# happyReduction_90 -happyReduction_90 = happyIn20 - ([] - ) - -happyReduce_91 = happySpecReduce_3 14# happyReduction_91 -happyReduction_91 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn20 - ([(happy_var_1,happy_var_3)] - )}} - -happyReduce_92 = happyReduce 5# 14# happyReduction_92 -happyReduction_92 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn20 - ((happy_var_1,happy_var_3):happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_93 = happySpecReduce_1 15# happyReduction_93 -happyReduction_93 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenInt happy_var_1) -> - happyIn21 - (MkInt happy_var_1 - )} - -happyReduce_94 = happySpecReduce_1 15# happyReduction_94 -happyReduction_94 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenBigInt happy_var_1) -> - happyIn21 - (MkBigInt happy_var_1 - )} - -happyReduce_95 = happySpecReduce_1 15# happyReduction_95 -happyReduction_95 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenChar happy_var_1) -> - happyIn21 - (MkChar happy_var_1 - )} - -happyReduce_96 = happySpecReduce_1 15# happyReduction_96 -happyReduction_96 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenBool happy_var_1) -> - happyIn21 - (MkBool happy_var_1 - )} - -happyReduce_97 = happySpecReduce_1 15# happyReduction_97 -happyReduction_97 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenFloat happy_var_1) -> - happyIn21 - (MkFloat happy_var_1 - )} - -happyReduce_98 = happySpecReduce_1 15# happyReduction_98 -happyReduction_98 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenBigFloat happy_var_1) -> - happyIn21 - (MkBigFloat happy_var_1 - )} - -happyReduce_99 = happySpecReduce_1 15# happyReduction_99 -happyReduction_99 happy_x_1 - = case happyOutTok happy_x_1 of { (TokenString happy_var_1) -> - happyIn21 - (MkString happy_var_1 - )} - -happyReduce_100 = happySpecReduce_1 15# happyReduction_100 -happyReduction_100 happy_x_1 - = happyIn21 - (MkUnit - ) - -happyReduce_101 = happySpecReduce_1 15# happyReduction_101 -happyReduction_101 happy_x_1 - = happyIn21 - (MkUnused - ) - -happyReduce_102 = happyMonadReduce 0# 16# happyReduction_102 -happyReduction_102 (happyRest) tk - = happyThen (( getLineNo) - ) (\r -> happyReturn (happyIn22 r)) - -happyReduce_103 = happyMonadReduce 0# 17# happyReduction_103 -happyReduction_103 (happyRest) tk - = happyThen (( getFileName) - ) (\r -> happyReturn (happyIn23 r)) - -happyNewToken action sts stk - = lexer(\tk -> - let cont i = happyDoAction i tk action sts stk in - case tk of { - TokenEOF -> happyDoAction 85# tk action sts stk; - TokenName happy_dollar_dollar -> cont 1#; - TokenString happy_dollar_dollar -> cont 2#; - TokenInt happy_dollar_dollar -> cont 3#; - TokenBigInt happy_dollar_dollar -> cont 4#; - TokenBool happy_dollar_dollar -> cont 5#; - TokenFloat happy_dollar_dollar -> cont 6#; - TokenBigFloat happy_dollar_dollar -> cont 7#; - TokenChar happy_dollar_dollar -> cont 8#; - TokenIntType -> cont 9#; - TokenBigIntType -> cont 10#; - TokenCharType -> cont 11#; - TokenBoolType -> cont 12#; - TokenFloatType -> cont 13#; - TokenBigFloatType -> cont 14#; - TokenStringType -> cont 15#; - TokenPtrType -> cont 16#; - TokenUnitType -> cont 17#; - TokenFunType -> cont 18#; - TokenDataType -> cont 19#; - TokenTyCType -> cont 20#; - TokenAnyType -> cont 21#; - TokenUnit -> cont 22#; - TokenCon -> cont 23#; - TokenDefault -> cont 24#; - TokenLet -> cont 25#; - TokenCase -> cont 26#; - TokenOf -> cont 27#; - TokenIf -> cont 28#; - TokenThen -> cont 29#; - TokenElse -> cont 30#; - TokenWhile -> cont 31#; - TokenMemory -> cont 32#; - TokenFixed -> cont 33#; - TokenGrowable -> cont 34#; - TokenUnused -> cont 35#; - TokenIn -> cont 36#; - TokenLazy -> cont 37#; - TokenStrict -> cont 38#; - TokenEffect -> cont 39#; - TokenForeign -> cont 40#; - TokenError -> cont 41#; - TokenImpossible -> cont 42#; - TokenOB -> cont 43#; - TokenCB -> cont 44#; - TokenOCB -> cont 45#; - TokenCCB -> cont 46#; - TokenOSB -> cont 47#; - TokenCSB -> cont 48#; - TokenPlus -> cont 49#; - TokenMinus -> cont 50#; - TokenTimes -> cont 51#; - TokenDivide -> cont 52#; - TokenMod -> cont 53#; - TokenFPlus -> cont 54#; - TokenFMinus -> cont 55#; - TokenFTimes -> cont 56#; - TokenFDivide -> cont 57#; - TokenEquals -> cont 58#; - TokenEQ -> cont 59#; - TokenLE -> cont 60#; - TokenGE -> cont 61#; - TokenFEQ -> cont 62#; - TokenFLE -> cont 63#; - TokenFGE -> cont 64#; - TokenShL -> cont 65#; - TokenShR -> cont 66#; - TokenLT -> cont 67#; - TokenGT -> cont 68#; - TokenFLT -> cont 69#; - TokenFGT -> cont 70#; - TokenColon -> cont 71#; - TokenProj -> cont 72#; - TokenSemi -> cont 73#; - TokenComma -> cont 74#; - TokenBar -> cont 75#; - TokenDot -> cont 76#; - TokenLam -> cont 77#; - TokenArrow -> cont 78#; - TokenCInclude -> cont 79#; - TokenExtern -> cont 80#; - TokenExport -> cont 81#; - TokenCType -> cont 82#; - TokenInclude -> cont 83#; - TokenInline -> cont 84#; - _ -> happyError' tk - }) - -happyError_ tk = happyError' tk - -happyThen :: () => P a -> (a -> P b) -> P b -happyThen = (thenP) -happyReturn :: () => a -> P a -happyReturn = (returnP) -happyThen1 = happyThen -happyReturn1 :: () => a -> P a -happyReturn1 = happyReturn -happyError' :: () => (Token) -> P a -happyError' tk = (\token -> happyError) tk - -mkparse = happySomeParser where - happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut6 x)) - -mkexpr = happySomeParser where - happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut13 x)) - -mkdecl = happySomeParser where - happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut8 x)) - -happySeq = happyDontSeq - - -mkBind :: Name -> [Type] -> Type -> [Name] -> Expr -> Maybe String -> [CGFlag] -> Decl -mkBind n tys ret ns expr export fl = Decl n ret (Bind (zip ns tys) 0 expr fl) export fl - -mkExtern :: Name -> [Type] -> Type -> [Name] -> Decl -mkExtern n tys ret ns = Extern n ret tys - -parse :: String -> FilePath -> Result [Decl] -parse s fn = mkparse s fn 1 - -parseExpr :: String -> Result Expr -parseExpr s = mkexpr s "[expr]" 1 - -parseDecl :: String -> Result Decl -parseDecl s = mkdecl s "[decl]" 1 - -parseFile :: FilePath -> IO (Result [Decl]) -parseFile fn = do s <- readFile fn - let x = parse s fn - return x -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} --- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp - -{-# LINE 30 "templates/GenericTemplate.hs" #-} - - -data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList - - - - - -{-# LINE 51 "templates/GenericTemplate.hs" #-} - -{-# LINE 61 "templates/GenericTemplate.hs" #-} - -{-# LINE 70 "templates/GenericTemplate.hs" #-} - -infixr 9 `HappyStk` -data HappyStk a = HappyStk a (HappyStk a) - ------------------------------------------------------------------------------ --- starting the parse - -happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll - ------------------------------------------------------------------------------ --- Accepting the parse - --- If the current token is 0#, it means we've just accepted a partial --- parse (a %partial parser). We must ignore the saved token on the top of --- the stack in this case. -happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = - happyReturn1 ans -happyAccept j tk st sts (HappyStk ans _) = - (happyTcHack j (happyTcHack st)) (happyReturn1 ans) - ------------------------------------------------------------------------------ --- Arrays only: do the next action - - - -happyDoAction i tk st - = {- nothing -} - - - case action of - 0# -> {- nothing -} - happyFail i tk st - -1# -> {- nothing -} - happyAccept i tk st - n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} - - (happyReduceArr Happy_Data_Array.! rule) i tk st - where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) - n -> {- nothing -} - - - happyShift new_state i tk st - where !(new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) - where !(off) = indexShortOffAddr happyActOffsets st - !(off_i) = (off Happy_GHC_Exts.+# i) - check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#)) - then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i) - else False - !(action) - | check = indexShortOffAddr happyTable off_i - | otherwise = indexShortOffAddr happyDefActions st - -{-# LINE 130 "templates/GenericTemplate.hs" #-} - - -indexShortOffAddr (HappyA# arr) off = - Happy_GHC_Exts.narrow16Int# i - where - !i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) - !high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) - !low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) - !off' = off Happy_GHC_Exts.*# 2# - - - - - -data HappyAddr = HappyA# Happy_GHC_Exts.Addr# - - - - ------------------------------------------------------------------------------ --- HappyState data type (not arrays) - -{-# LINE 163 "templates/GenericTemplate.hs" #-} - ------------------------------------------------------------------------------ --- Shifting a token - -happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = - let !(i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in --- trace "shifting the error token" $ - happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) - -happyShift new_state i tk st sts stk = - happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) - --- happyReduce is specialised for the common cases. - -happySpecReduce_0 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_0 nt fn j tk st@((action)) sts stk - = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) - -happySpecReduce_1 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') - = let r = fn v1 in - happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) - -happySpecReduce_2 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') - = let r = fn v1 v2 in - happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) - -happySpecReduce_3 i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') - = let r = fn v1 v2 v3 in - happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) - -happyReduce k i fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happyReduce k nt fn j tk st sts stk - = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of - sts1@((HappyCons (st1@(action)) (_))) -> - let r = fn stk in -- it doesn't hurt to always seq here... - happyDoSeq r (happyGoto nt j tk st1 sts1 r) - -happyMonadReduce k nt fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happyMonadReduce k nt fn j tk st sts stk = - happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) - where !(sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts)) - drop_stk = happyDropStk k stk - -happyMonad2Reduce k nt fn 0# tk st sts stk - = happyFail 0# tk st sts stk -happyMonad2Reduce k nt fn j tk st sts stk = - happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) - where !(sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts)) - drop_stk = happyDropStk k stk - - !(off) = indexShortOffAddr happyGotoOffsets st1 - !(off_i) = (off Happy_GHC_Exts.+# nt) - !(new_state) = indexShortOffAddr happyTable off_i - - - - -happyDrop 0# l = l -happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t - -happyDropStk 0# l = l -happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs - ------------------------------------------------------------------------------ --- Moving to a new state after a reduction - - -happyGoto nt j tk st = - {- nothing -} - happyDoAction j tk new_state - where !(off) = indexShortOffAddr happyGotoOffsets st - !(off_i) = (off Happy_GHC_Exts.+# nt) - !(new_state) = indexShortOffAddr happyTable off_i - - - - ------------------------------------------------------------------------------ --- Error recovery (0# is the error token) - --- parse error if we are in recovery and we fail again -happyFail 0# tk old_st _ stk = --- trace "failing" $ - happyError_ tk - -{- We don't need state discarding for our restricted implementation of - "error". In fact, it can cause some bogus parses, so I've disabled it - for now --SDM - --- discard a state -happyFail 0# tk old_st (HappyCons ((action)) (sts)) - (saved_tok `HappyStk` _ `HappyStk` stk) = --- trace ("discarding state, depth " ++ show (length stk)) $ - happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk)) --} - --- Enter error recovery: generate an error token, --- save the old token and carry on. -happyFail i tk (action) sts stk = --- trace "entering error recovery" $ - happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) - --- Internal happy errors: - -notHappyAtAll = error "Internal Happy error\n" - ------------------------------------------------------------------------------ --- Hack to get the typechecker to accept our action functions - - -happyTcHack :: Happy_GHC_Exts.Int# -> a -> a -happyTcHack x y = y -{-# INLINE happyTcHack #-} - - ------------------------------------------------------------------------------ --- Seq-ing. If the --strict flag is given, then Happy emits --- happySeq = happyDoSeq --- otherwise it emits --- happySeq = happyDontSeq - -happyDoSeq, happyDontSeq :: a -> b -> b -happyDoSeq a b = a `seq` b -happyDontSeq a b = b - ------------------------------------------------------------------------------ --- Don't inline any functions from the template. GHC has a nasty habit --- of deciding to inline happyGoto everywhere, which increases the size of --- the generated parser quite a bit. - - -{-# NOINLINE happyDoAction #-} -{-# NOINLINE happyTable #-} -{-# NOINLINE happyCheck #-} -{-# NOINLINE happyActOffsets #-} -{-# NOINLINE happyGotoOffsets #-} -{-# NOINLINE happyDefActions #-} - -{-# NOINLINE happyShift #-} -{-# NOINLINE happySpecReduce_0 #-} -{-# NOINLINE happySpecReduce_1 #-} -{-# NOINLINE happySpecReduce_2 #-} -{-# NOINLINE happySpecReduce_3 #-} -{-# NOINLINE happyReduce #-} -{-# NOINLINE happyMonadReduce #-} -{-# NOINLINE happyGoto #-} -{-# NOINLINE happyFail #-} - --- end of Happy Template. diff --git a/epic.cabal b/epic.cabal --- a/epic.cabal +++ b/epic.cabal @@ -1,5 +1,5 @@ Name: epic -Version: 0.1.11 +Version: 0.1.13 Author: Edwin Brady License: BSD3 License-file: LICENSE @@ -25,15 +25,17 @@ Library Exposed-modules: Epic.Compiler Epic.Epic Other-modules: Epic.Bytecode Epic.Parser Epic.Scopecheck - Epic.Language Epic.Lexer Epic.CodegenC - Epic.OTTLang Epic.Simplify Paths_epic - Build-depends: base >=4 && <5 , haskell98, mtl, Cabal, array, directory - + Epic.Language Epic.Lexer Epic.CodegenC Epic.CodegenStack + Epic.OTTLang Epic.Simplify Epic.Stackcode + Epic.Evaluator Paths_epic + Build-depends: base >=4 && <5 , haskell98, mtl, Cabal, array, directory, process + Extensions: BangPatterns Executable epic Main-is: Main.lhs Other-modules: Epic.Bytecode Epic.Parser Epic.Scopecheck - Epic.Language Epic.Lexer Epic.CodegenC - Epic.OTTLang Epic.Simplify Paths_epic - Build-depends: base >=4 && <5, mtl, array, haskell98, Cabal, directory - + Epic.Language Epic.Lexer Epic.CodegenC Epic.CodegenStack + Epic.OTTLang Epic.Simplify Epic.Stackcode + Epic.Evaluator Paths_epic + Build-depends: base >=4 && <5, mtl, array, haskell98, Cabal, directory, process + Extensions: BangPatterns diff --git a/evm/closure.c b/evm/closure.c --- a/evm/closure.c +++ b/evm/closure.c @@ -15,6 +15,8 @@ extern func _do___U__main(); +void epicMemInfo(); + ALLOCATOR allocate; REALLOCATOR reallocate; pool_t** pools = NULL; @@ -642,7 +644,7 @@ fn->arg_end[2] = a3; fn->arg_end[3] = a4; fn->arg_end[4] = a5; - fn->arg_end+=2; + fn->arg_end+=5; return x; } @@ -792,7 +794,9 @@ block[got] = a1; return (VAL)(finf->fn(block)); } - else return CLOSURE_ADD1(f,a1); + else if (finf->arity < (got+1)) { + return (VAL) DO_EVAL(CLOSURE_ADD1(f,a1), 0); + } else return CLOSURE_ADD1(f,a1); } else return aux_CLOSURE_APPLY1(f,a1); } @@ -813,8 +817,9 @@ block[got] = a1; block[got+1] = a2; return (VAL)(finf->fn(block)); - } - else return CLOSURE_ADD2(f,a1,a2); + } else if (finf->arity < (got+2)) { + return (VAL) DO_EVAL(CLOSURE_ADD2(f,a1,a2), 0); + } else return CLOSURE_ADD2(f,a1,a2); } else return aux_CLOSURE_APPLY2(f,a1,a2); } @@ -832,7 +837,9 @@ block[got+2] = a3; return (VAL)(finf->fn(block)); } - else return CLOSURE_ADD3(f,a1,a2,a3); + else if (finf->arity < (got+3)) { + return (VAL) DO_EVAL(CLOSURE_ADD3(f,a1,a2,a3), 0); + } else return CLOSURE_ADD3(f,a1,a2,a3); } else return aux_CLOSURE_APPLY3(f,a1,a2,a3); } @@ -851,7 +858,9 @@ block[got+3] = a4; return (VAL)(finf->fn(block)); } - else return CLOSURE_ADD4(f,a1,a2,a3,a4); + else if (finf->arity < (got+4)) { + return (VAL) DO_EVAL(CLOSURE_ADD4(f,a1,a2,a3,a4), 0); + } else return CLOSURE_ADD4(f,a1,a2,a3,a4); } else return aux_CLOSURE_APPLY4(f,a1,a2,a3,a4); } @@ -871,7 +880,9 @@ block[got+4] = a5; return (VAL)(finf->fn(block)); } - else return CLOSURE_ADD5(f,a1,a2,a3,a4,a5); + else if (finf->arity < (got+5)) { + return (VAL) DO_EVAL(CLOSURE_ADD5(f,a1,a2,a3,a4,a5), 0); + } else return CLOSURE_ADD5(f,a1,a2,a3,a4,a5); } else return aux_CLOSURE_APPLY5(f,a1,a2,a3,a4,a5); } @@ -891,6 +902,7 @@ switch(GETTY(x)) { case CON: case INT: + case BIGINT: case FLOAT: case STRING: case PTR: @@ -1164,11 +1176,22 @@ return vm; } +void wrap_GC_free(void * a, size_t b) { + GC_free(a); +} + +void* wrap_GC_realloc(void *ptr, size_t old, size_t new) { + return GC_realloc(ptr, new); +} void epic_main(int argc, char* argv[]) { GC_init(); + + + vm = init_evm(argc, argv); + mp_set_memory_functions(GC_malloc_atomic, wrap_GC_realloc, wrap_GC_free); // GC_use_entire_heap = 1; // GC_free_space_divisor = 2; @@ -1197,7 +1220,7 @@ fprintf(stderr, "Warning: roots left %d\n", vm->roots-vm->start_roots); } */ - +// epicMemInfo(); close_evm(vm); } diff --git a/evm/libevm.a b/evm/libevm.a Binary files a/evm/libevm.a and b/evm/libevm.a differ diff --git a/evm/stdfuns.c b/evm/stdfuns.c --- a/evm/stdfuns.c +++ b/evm/stdfuns.c @@ -368,10 +368,7 @@ char* bigIntToStr(mpz_t x) { char* str = mpz_get_str(NULL,10,x); - char* buf = EMALLOC(strlen(str)+1); - strcpy(buf,str); - free(str); - return buf; + return str; } VAL strToBig(char* str) {