diff --git a/Epic/Bytecode.lhs b/Epic/Bytecode.lhs --- a/Epic/Bytecode.lhs +++ b/Epic/Bytecode.lhs @@ -239,6 +239,15 @@ > TyUnit -> [ASSIGN vs reg'] > _ -> [ASSIGN vs reg'] > return $ valcode ++ assigncode ++ (ADDVARROOT vs):scopecode + +As above, but don't create a new local + +> ecomp lazy tcall (Update i val scope) reg vs = +> do reg' <- new_tmp +> valcode <- ecomp lazy Middle val reg' vs +> scopecode <- ecomp lazy tcall scope reg vs +> let assigncode = [ASSIGN i reg'] +> return $ valcode ++ assigncode ++ scopecode > ecomp lazy tcall (Error str) reg vs = return [ERROR str] > ecomp lazy tcall Impossible reg vs = return [ERROR "The impossible happened."] > ecomp lazy tcall (ForeignCall ty fn argtypes) reg vs = do diff --git a/Epic/CodegenC.lhs b/Epic/CodegenC.lhs --- a/Epic/CodegenC.lhs +++ b/Epic/CodegenC.lhs @@ -270,7 +270,7 @@ > cToEpic var TyString = "MKSTR((char*)(" ++ var ++ "))" > cToEpic var TyInt = "MKINT(INTTOEINT(" ++ var ++ "))" > cToEpic var TyPtr = "MKPTR(" ++ var ++ ")" -> cToEpic var TyBigInt = "MKBIGINT((mpz_t*)(" ++ var ++ "))" +> -- cToEpic var TyBigInt = "MKBIGINT((mpz_t*)(" ++ var ++ "))" -- now just a VAL > cToEpic var TyFloat = "MKFLOAT(" ++ var ++ ")" > cToEpic var TyUnit = "NULL" > cToEpic var _ = "(void*)(" ++ var ++")" @@ -287,7 +287,7 @@ castFrom t _ rest = tmp t ++ " = (void*)(" ++ rest ++ ")" > epicToC t TyInt = "EINTTOINT(GETINT("++ t ++"))" -> epicToC t TyBigInt = "*(GETBIGINT("++ t ++"))" +> -- epicToC t TyBigInt = "*(GETBIGINT("++ t ++"))" -- now just a VAL > epicToC t TyString = "GETSTR("++ t ++")" > epicToC t TyFloat = "GETFLOAT(" ++ t ++ ")" > epicToC t TyPtr = "GETPTR("++ t ++")" @@ -306,6 +306,7 @@ > doOp t Minus l r = tmp t ++ " = INTOP(-,"++tmp l ++ ", "++tmp r++");" > doOp t Times l r = tmp t ++ " = MULT("++tmp l ++ ", "++tmp r++");" > doOp t Divide l r = tmp t ++ " = INTOP(/,"++tmp l ++ ", "++tmp r++");" +> doOp t Modulo l r = tmp t ++ " = INTOP(%,"++tmp l ++ ", "++tmp r++");" > doOp t FPlus l r = tmp t ++ " = FLOATOP(+,"++tmp l ++ ", "++tmp r++");" > doOp t FMinus l r = tmp t ++ " = FLOATOP(-,"++tmp l ++ ", "++tmp r++");" > doOp t FTimes l r = tmp t ++ " = FLOATOP(*,"++tmp l ++ ", "++tmp r++");" diff --git a/Epic/Epic.lhs b/Epic/Epic.lhs --- a/Epic/Epic.lhs +++ b/Epic/Epic.lhs @@ -16,14 +16,20 @@ > Expr, Term, Name, name, > (@@), case_, con_, tuple_, con, tuple, > constcase, defaultcase, -> if_, while_, whileAcc_, error_, op_, +> if_, while_, whileAcc_, error_, > lazy_, effect_, > foreign_, foreignL_, foreignConst_, foreignConstL_, -> let_, letN_, Op(..), +> let_, letN_, update_, op_, > str, int, float, char, bool, unit_, (!.), fn, ref, (+>), +> malloc_, > -- * Types > Type, tyInt, tyChar, tyBool, tyFloat, tyString, -> tyPtr, tyUnit, tyAny, tyC, +> tyPtr, tyUnit, tyAny, tyC, +> -- * Operators +> plus_, minus_, times_, divide_, +> plusF_, minusF_, timesF_, divideF_, +> eq_, lt_, lte_, gt_, gte_, +> eqF_, ltF_, lteF_, gtF_, gteF_, shiftl_, shiftr_, > -- * Declarations and programs > EpicDecl(..), Program, > -- * Compiling and execution @@ -42,6 +48,7 @@ > import Epic.Language > import Epic.Compiler +> import Epic.Parser Allow Haskell functions to be used to build expressions. @@ -58,18 +65,21 @@ > instance EpicExpr Term where > term e = e -> instance (EpicExpr e) => EpicExpr (Expr -> e) where +> instance EpicExpr String where +> term s = case parseExpr s of +> Success t -> return t +> Failure err f l -> fail err + +> instance EpicExpr e => EpicExpr (Expr -> e) where > term f = do var <- get > put (var+1) > let arg = MN "evar" var > e' <- term (f (R arg)) > return (Lam arg TyAny e') -> instance EpicExpr ([Name], Expr) where -> term (ns, e) = lam ns e where -> lam [] e = return e -> lam (n:ns) e = do e' <- lam ns e -> return (Lam n TyAny e') +> instance EpicExpr e => EpicExpr ([Name], e) where +> term (ns, e) = do e' <- term e +> foldM (\e n -> return (Lam n TyAny e)) e' ns > -- | Build a function definition, with a name supply > class EpicFn e where @@ -101,12 +111,34 @@ Binary operators -> eq = Op OpEQ -> lt = Op OpLT -> lte = Op OpLE -> gt = Op OpGT -> gte = Op OpGE +> plus_, minus_, times_, divide_, plusF_, minusF_, timesF_, divideF_ :: Op +> lt_, lte_, gt_, gte_, ltF_, lteF_, gtF_, gteF_, shiftl_, shiftr_ :: Op +> plus_ = Plus +> minus_ = Minus +> times_ = Times +> divide_ = Divide + +> plusF_ = FPlus +> minusF_ = FMinus +> timesF_ = FTimes +> divideF_ = FDivide + +> eq_ = OpEQ +> lt_ = OpLT +> lte_ = OpLE +> gt_ = OpGT +> gte_ = OpGE + +> eqF_ = OpFEQ +> ltF_ = OpFLT +> lteF_ = OpFLE +> gtF_ = OpFGT +> gteF_ = OpFGE + +> shiftl_ = ShL +> shiftr_ = ShR + > mkFunc :: EpicFn e => e -> Func > mkFunc e = evalState (func e) 0 @@ -235,6 +267,15 @@ > foreignConst_ t str = term $ ForeignCall t str [] > foreignConstL_ t str = term $ LazyForeignCall t str [] +> -- | Evaluate an expression under manually allocated memory. Creates a pool +> -- of memory. All allocation is from this pool, and there is no garbage +> -- collection. The pool is freed after evaluation. +> malloc_ :: (EpicExpr a, EpicExpr b) => +> a -- ^ Size of block to allocate +> -> b -- ^ Expression to evaluate +> -> Term +> malloc_ = exp2 (WithMem FixedPool) + mkCon :: Int -> [Term] -> Term mkCon tag args = do args' <- mapM expr args return (Con tag args') @@ -261,15 +302,34 @@ > sc' <- term sc > return $ Let n TyAny val' sc' +> -- | Build expressions, with a name supply +> class LetExpr e where +> let_ :: EpicExpr val => val -> e -> State Int Expr + +> instance LetExpr (Expr -> Term) where +> let_ = letV_ + +> instance EpicExpr sc => LetExpr (Name, sc) where +> let_ val (n, sc) = letN_ n val sc + > -- | Let bindings with higher order syntax -> let_ :: (EpicExpr e) => +> letV_ :: (EpicExpr e) => > e -> (Expr -> Term) -> Term -> let_ e f = do e' <- term e -> f' <- f (R (MN "DUMMY" 0)) -> let var = MN "loc" (topVar f') -> fv <- f (R var) -> return $ Let var TyAny e' fv +> letV_ e f = do e' <- term e +> f' <- f (R (MN "DUMMY" 0)) +> let var = MN "loc" (topVar f') +> fv <- f (R var) +> return $ Let var TyAny e' fv +> -- | Update a local variable (could be an explicit name or bound with +> -- a lambda, so we let it be an 'Expr'. +> update_ :: (EpicExpr val, EpicExpr scope) => +> Expr -> val -> scope -> Term +> update_ (R n) val sc = do val' <- term val +> sc' <- term sc +> return $ LetM n val' sc' +> update_ _ _ _ = fail "Can't update something which isn't a variable" + > maxs = foldr max 0 > topVar (Let (MN "loc" x) _ _ _) = x+1 @@ -320,7 +380,7 @@ > -- | Sequence terms --- evaluate the first then second > (+>) :: (EpicExpr c) => c -> Term -> Term -> (+>) c k = let_ c (\x -> k) +> (+>) c k = let_ c (\(x :: Expr) -> k) > tyInt, tyChar, tyBool, tyFloat, tyString, tyPtr, tyUnit, tyAny :: Type > tyC :: String -> Type @@ -364,25 +424,25 @@ > _ -> return $ App f' [a'] > -- | Top level declarations -> data EpicDecl = forall e. EpicFn e => EpicFn e -- ^ Normal function +> data EpicDecl = forall e. EpicFn e => EpicFn Name e -- ^ Normal function > | Include String -- ^ Include a C header > | Link String -- ^ Link to a C library > | CType String -- ^ Export a C type > instance Show EpicDecl where -> show (EpicFn e) = show (evalState (func e) 0) +> show (EpicFn n e) = show (n, evalState (func e) 0) -> type Program = [(Name, EpicDecl)] +> type Program = [EpicDecl] > name :: String -> Name > name = UN -> mkDecl :: (Name, EpicDecl) -> Decl -> mkDecl (n, EpicFn e) = Decl n TyAny (mkFunc e) Nothing [] +> mkDecl :: EpicDecl -> Decl +> mkDecl (EpicFn n e) = Decl n TyAny (mkFunc e) Nothing [] > -- mkDecl (n, Epic.Epic.Extern nm ty tys) = Epic.Language.Extern nm ty tys -> mkDecl (n, Epic.Epic.Include f) = Epic.Language.Include f -> mkDecl (n, Epic.Epic.Link f) = Epic.Language.Link f -> mkDecl (n, Epic.Epic.CType f) = Epic.Language.CType f +> mkDecl (Epic.Epic.Include f) = Epic.Language.Include f +> mkDecl (Epic.Epic.Link f) = Epic.Language.Link f +> mkDecl (Epic.Epic.CType f) = Epic.Language.CType f > -- |Compile a program to an executable > compile :: Program -> FilePath -> IO () @@ -438,9 +498,10 @@ > intToString_ x = foreign_ tyString "intToStr" [(x, tyInt)] > -- | Some default definitions: putStr, putStrLn, readStr, append, intToString -> basic_defs = [(name "putStr", EpicFn putStr_), -> (name "putStrLn", EpicFn putStrLn_), -> (name "readStr", EpicFn readStr_), -> (name "append", EpicFn append_), -> (name "intToString", EpicFn intToString_)] +> basic_defs :: [EpicDecl] +> basic_defs = [EpicFn (name "putStr") putStr_, +> EpicFn (name "putStrLn") putStrLn_, +> EpicFn (name "readStr") readStr_, +> EpicFn (name "append") append_, +> EpicFn (name "intToString") intToString_] diff --git a/Epic/Language.lhs b/Epic/Language.lhs --- a/Epic/Language.lhs +++ b/Epic/Language.lhs @@ -108,6 +108,8 @@ > | WhileAcc Expr Expr Expr > | Op Op Expr Expr -- Infix operator > | Let Name Type Expr Expr -- Let binding +> | LetM Name Expr Expr -- Update a variable +> | Update Int Expr Expr -- Update a variable (scope-checked) > | Lam Name Type Expr -- inner lambda > | Error String -- Exit with error message > | Impossible -- Claimed impossible to reach code @@ -134,7 +136,8 @@ > data Allocator = FixedPool | GrowablePool > deriving Eq -> data Op = Plus | Minus | Times | Divide | OpEQ | OpLT | OpLE | OpGT | OpGE +> data Op = Plus | Minus | Times | Divide | Modulo +> | OpEQ | OpLT | OpLE | OpGT | OpGE > | FPlus | FMinus | FTimes | FDivide > | OpFEQ | OpFLT | OpFLE | OpFGT | OpFGE > | ShL | ShR @@ -161,6 +164,10 @@ > ", " ++ show a ++ ")" > show (Op o l r) = "(" ++ show l ++ " " ++ show o ++ " " ++ show r ++")" > show (Let n t v e) = "let " ++ show n ++ ":" ++ show t ++ " = " ++ +> show v ++ " in " ++ show e +> show (LetM n v e) = "let! " ++ show n ++ " = " ++ +> show v ++ " in " ++ show e +> show (Update n v e) = "let! var" ++ show n ++ " = " ++ > show v ++ " in " ++ show e > show (Lam n t e) = "\\ " ++ show n ++ ":" ++ show t ++ " . " ++ > show e diff --git a/Epic/Lexer.lhs b/Epic/Lexer.lhs --- a/Epic/Lexer.lhs +++ b/Epic/Lexer.lhs @@ -79,6 +79,7 @@ > | TokenMinus > | TokenTimes > | TokenDivide +> | TokenMod > | TokenFPlus > | TokenFMinus > | TokenFTimes @@ -179,7 +180,8 @@ > lexer cont ('|':cs) = cont TokenBar cs > lexer cont ('.':cs) = cont TokenDot cs > lexer cont ('\\':cs) = cont TokenLam cs -> lexer cont ('%':cs) = lexSpecial cont cs +> lexer cont ('%':c:cs) | isAlpha c = lexSpecial cont (c:cs) +> lexer cont ('%':cs) = cont TokenMod cs > lexer cont (c:cs) = lexError c cs > lexError c s f l = failP (show l ++ ": Unrecognised token '" ++ [c] ++ "'\n") s f l @@ -284,7 +286,7 @@ > ("fixed",rest) -> cont TokenFixed rest > ("growable",rest) -> cont TokenGrowable rest > ("unused", rest) -> cont TokenUnused rest -> (thing,rest) -> lexError '%' rest +> (thing,rest) -> cont TokenMod (thing++rest) > mkname :: String -> Token > mkname c = TokenName (UN c) diff --git a/Epic/Parser.y b/Epic/Parser.y --- a/Epic/Parser.y +++ b/Epic/Parser.y @@ -12,6 +12,8 @@ } %name mkparse Program +%name mkexpr Expr +%name mkdecl Declaration %tokentype { Token } %monad { P } { thenP } { returnP } @@ -71,6 +73,7 @@ '-' { TokenMinus } '*' { TokenTimes } '/' { TokenDivide } + '%' { TokenMod } fplus { TokenFPlus } fminus { TokenFMinus } ftimes { TokenFTimes } @@ -112,7 +115,7 @@ %left '<' '>' le ge flt fgt fle fge %left shl shr %left '+' '-' fplus fminus -%left '*' '/' ftimes fdiv +%left '*' '/' ftimes fdiv '%' %left NEG %left '!' %nonassoc '(' @@ -182,6 +185,7 @@ | Const { Const $1 } | Expr '!' int { Proj $1 $3 } | let name ':' Type '=' Expr in Expr %prec LET { Let $2 $4 $6 $8 } + | let '!' name '=' Expr in Expr %prec LET { LetM $3 $5 $7 } | '\\' name ':' Type '.' Expr %prec LET { Lam $2 $4 $6 } | Expr ';' Expr { Let (MN "unused" 0) TyUnit $1 $3 } | if Expr then Expr else Expr %prec IF { If $2 $4 $6 } @@ -222,6 +226,7 @@ | '-' Expr %prec NEG { Op Minus (Const (MkInt 0)) $2 } | Expr '*' Expr { Op Times $1 $3 } | Expr '/' Expr { Op Divide $1 $3 } + | Expr '%' Expr { Op Modulo $1 $3 } | Expr fplus Expr { Op FPlus $1 $3 } | Expr fminus Expr { Op FMinus $1 $3 } @@ -280,6 +285,12 @@ 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 diff --git a/Epic/Scopecheck.lhs b/Epic/Scopecheck.lhs --- a/Epic/Scopecheck.lhs +++ b/Epic/Scopecheck.lhs @@ -51,6 +51,11 @@ > else return $ Const (MkInt 1234567890) > (Just _) -> return $ R n > (Just i) -> return $ V i +> tc env (LetM n v sc) = case lookup n env of +> Nothing -> lift $ fail $ "Unknown local to update" ++ showuser n +> (Just i) -> do v' <- tc env v +> sc' <- tc env sc +> return $ Update i v' sc' > tc env (Let n ty v sc) = do > v' <- tc env v > sc' <- tc ((n,length env):env) sc diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2006 Edwin Brady +Copyright (c) 2006-10 Edwin Brady School of Computer Science, University of St Andrews All rights reserved. diff --git a/dist/build/Epic/Parser.hs b/dist/build/Epic/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/Epic/Parser.hs @@ -0,0 +1,1587 @@ +{-# 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.8 +Version: 0.1.10 Author: Edwin Brady License: BSD3 License-file: LICENSE diff --git a/evm/closure.c b/evm/closure.c --- a/evm/closure.c +++ b/evm/closure.c @@ -76,7 +76,7 @@ printf("BIGFLOAT["); break; case STRING: - printf("STRING["); + printf("STRING[%s", ((char*)c->info)); break; case UNIT: printf("UNIT["); @@ -850,7 +850,7 @@ } */ - /*void* MKINT(int x) +/*void* MKINT(int x) { return (void*)((x<<1)+1); // VAL c = MKCLOSURE; @@ -859,6 +859,28 @@ // return c; }*/ +mpz_t* NEWBIGINTI(int val) +{ + mpz_t* bigint = EMALLOC(sizeof(mpz_t)); + mpz_init(*bigint); + mpz_set_si(*bigint, val); + return bigint; +} + +void* NEWBIGINTVALI(int val) +{ + mpz_t* bigint; + VAL c = EMALLOC(sizeof(Closure)+sizeof(mpz_t)); + bigint = (mpz_t*)(c+1); + mpz_init(*bigint); + mpz_set_si(*bigint, val); + + SETTY(c, BIGINT); + c->info = (void*)bigint; + EREADY(c); + return c; +} + void* NEWBIGINT(char* intstr) { mpz_t* bigint; @@ -911,7 +933,11 @@ mpz_t* GETBIGINT(void* x) { - return (mpz_t*)(((VAL)x)->info); + if (ISINT(x)) { + return NEWBIGINTI(GETINT(x)); + } else { + return (mpz_t*)(((VAL)x)->info); + } } double GETFLOAT(void* x) @@ -919,7 +945,7 @@ return *((double*)(((VAL)x)->info)); } -void* MKSTR(char* x) +void* MKSTR(const char* x) { // VAL c = EMALLOC(sizeof(Closure)+strlen(x)+sizeof(char)+1); //MKCLOSURE; VAL c = EMALLOC(sizeof(Closure)); @@ -929,7 +955,7 @@ // Since MKSTR is used to build strings from foreign calls, the string // itself will already have been allocated so we just want the closure. - c->info=x; + c->info=(void*)x; EREADY(c); return c; } @@ -964,6 +990,14 @@ return c; } +void slide(VMState* vm, int lose, int keep) { + int i; + for(i = 1; i <= keep; i++) { + vm->stack_top[-(lose+i)] = *(vm->stack_top-i); + } + vm->stack_top-=lose; +} + VAL evm_getArg(int i) { if (i>=0 && istack = malloc(sizeof(VAL)*STACK_INIT); + vm->stack_top = vm->stack+STACK_INIT; + vm->stack_top = vm->stack; + +/* vm->roots = malloc(sizeof(VAL)*1024); vm->start_roots = vm->roots; @@ -1015,7 +1053,7 @@ vm->next_nursery = 0; vm->next = 0; */ - return NULL; + return vm; } void epic_main(int argc, char* argv[]) diff --git a/evm/closure.h b/evm/closure.h --- a/evm/closure.h +++ b/evm/closure.h @@ -145,11 +145,25 @@ VAL* to_space; VAL* nursery; + VAL* stack; + VAL* stack_top; + VAL* stack_limit; + int heap_size; int next; int next_nursery; } VMState; +#define STACK_INIT 8192 + +#define STACK(x) (*(vm->stack_top-x)) +#define PUSH(x) vm->stack_top=x; vm->stack_top++; +#define DROP(x) vm->stack_top-=x; +#define SLIDE1(x) vm->stack_top[-(x+1)]=*(vm->stack_top-1); vm->stack_top-=x; +#define SLIDE(x,keep) slide(vm,x,keep); + +void slide(VMState* vm, int lose, int keep); + extern void* e_malloc(VMState* vm, size_t size); extern void* e_realloc(VMState* vm, void* ptr, size_t size); @@ -257,10 +271,12 @@ #define EINTTOINT(x) ((int)(x)) //void* MKINT(int x); +mpz_t* NEWBIGINTI(int val); +void* NEWBIGINTVALI(int val); void* NEWBIGINT(char* bigint); void* MKBIGINT(mpz_t* bigint); -void* MKSTR(char* str); +void* MKSTR(const char* str); void* MKPTR(void* ptr); void* MKFLOAT(double x); 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 @@ -9,6 +9,14 @@ void printInt(int x) { printf("%d\n",x); } void putStr(char* s) { printf("%s",s); } void printBigInt(mpz_t x) { printf("%s\n",mpz_get_str(NULL,10,x)); } +void printBig(VAL x) +{ + if (ISINT(x)) { + printf("%ld INT\n", GETINT(x)); + } else { + printBigInt(*(GETBIGINT(x))); + } +} void epicGC() { #ifdef USE_BOEHM @@ -184,54 +192,171 @@ return answer; } +VAL addBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + int vx = GETINT(x); + int vy = GETINT(y); + if ((vx <= 0 && vy >=0) || (vx >=0 && vy <=0)) { + return INTOP(+,x,y); + } + int res = vx + vy; + if (res >= 1<<30 || res <= -(1 << 30)) { + return MKBIGINT(addBigInt(*(NEWBIGINTI(vx)), *(NEWBIGINTI(vy)))); + } else { + return MKINT(res); + } + } else { + return MKBIGINT(addBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + mpz_t* subBigInt(mpz_t x, mpz_t y) { mpz_t* answer = EMALLOC(sizeof(mpz_t)); mpz_sub(*answer, x, y); return answer; } +VAL subBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + int vx = GETINT(x); + int vy = GETINT(y); + if ((vx <= 0 && vy <=0) || (vx >=0 && vy >=0)) { + return INTOP(-,x,y); + } + int res = vx - vy; + if (res >= 1<<30 || res <= -(1 << 30)) { + return MKBIGINT(subBigInt(*(NEWBIGINTI(vx)), *(NEWBIGINTI(vy)))); + } else { + return MKINT(res); + } + } else { + return MKBIGINT(subBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + mpz_t* mulBigInt(mpz_t x, mpz_t y) { mpz_t* answer = EMALLOC(sizeof(mpz_t)); mpz_mul(*answer, x, y); return answer; } +VAL mulBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + int vx = abs(GETINT(x)); + int vy = abs(GETINT(y)); + // we could work out likelihood of overflow by checking the number + // of necessary bits. Here's a quick conservative hack instead. + if ((vx < (1<<15) && vy < (1<16)) || + (vx < (1<<16) && vy < (1<15)) || + (vx < (1<<20) && vy < (1<11)) || + (vx < (1<<11) && vy < (1<20)) || + (vx < (1<<23) && vy < (1<<8)) || + (vx < (1<<8) && vy < (1<<23))) { // ultra-conservative! + return INTOP(*,x,y); + } else { + mpz_t *resb = mulBigInt(*(NEWBIGINTI(vx)), *(NEWBIGINTI(vy))); + VAL res = MKBIGINT(resb); + return res; + } + } else { + return MKBIGINT(mulBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + mpz_t* divBigInt(mpz_t x, mpz_t y) { mpz_t* answer = EMALLOC(sizeof(mpz_t)); mpz_tdiv_q(*answer, x, y); return answer; } +VAL divBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + // always gets smaller, so it's safe + return INTOP(/, x, y); + } else { + return MKBIGINT(divBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + mpz_t* modBigInt(mpz_t x, mpz_t y) { mpz_t* answer = EMALLOC(sizeof(mpz_t)); mpz_tdiv_r(*answer, x, y); return answer; } +VAL modBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + // always gets smaller, so it's safe + return INTOP(%, x, y); + } else { + return MKBIGINT(modBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + int eqBigInt(mpz_t x, mpz_t y) { return mpz_cmp(x,y)==0; } +int eqBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + return (GETINT(x) == GETINT(y)); + } else { + return (eqBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + int ltBigInt(mpz_t x, mpz_t y) { return mpz_cmp(x,y)<0; } +int ltBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + return (GETINT(x) < GETINT(y)); + } else { + return (ltBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + int gtBigInt(mpz_t x, mpz_t y) { return mpz_cmp(x,y)>0; } +int gtBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + return (GETINT(x) > GETINT(y)); + } else { + return (gtBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + int leBigInt(mpz_t x, mpz_t y) { return mpz_cmp(x,y)<=0; } +int leBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + return (GETINT(x) <= GETINT(y)); + } else { + return (leBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + int geBigInt(mpz_t x, mpz_t y) { return mpz_cmp(x,y)>=0; } +int geBig(VAL x, VAL y) { + if (ISINT(x) && ISINT(y)) { + return (GETINT(x) >= GETINT(y)); + } else { + return (geBigInt(*(GETBIGINT(x)), *(GETBIGINT(y)))); + } +} + mpz_t* strToBigInt(char* str) { mpz_t* answer = EMALLOC(sizeof(mpz_t)); @@ -248,6 +373,19 @@ free(str); return buf; } + +VAL strToBig(char* str) { + return MKBIGINT(strToBigInt(str)); +} + +char* bigToStr(VAL x) { + if (ISINT(x)) { + return intToStr(GETINT(x)); + } else { + return bigIntToStr(*(GETBIGINT(x))); + } +} + // IORefs int numrefs = 0; diff --git a/evm/stdfuns.h b/evm/stdfuns.h --- a/evm/stdfuns.h +++ b/evm/stdfuns.h @@ -18,6 +18,7 @@ void putStr(char* str); void printInt(int x); void printBigInt(mpz_t x); +void printBig(VAL x); // dump memory usage (from libgc) void epicMemInfo(); @@ -65,6 +66,9 @@ mpz_t* strToBigInt(char* str); char* bigIntToStr(mpz_t x); +VAL strToBig(char* str); +char* bigToStr(VAL x); + // get a native representation of a value void* getNative(void * fn); @@ -93,6 +97,20 @@ int gtBigInt(mpz_t x, mpz_t y); int leBigInt(mpz_t x, mpz_t y); int geBigInt(mpz_t x, mpz_t y); + +// VAL versions, which can also cope with INT and promote to BIGINT if necessary + +VAL addBig(VAL x, VAL y); +VAL subBig(VAL x, VAL y); +VAL mulBig(VAL x, VAL y); +VAL divBig(VAL x, VAL y); +VAL modBig(VAL x, VAL y); + +int eqBig(VAL x, VAL y); +int ltBig(VAL x, VAL y); +int gtBig(VAL x, VAL y); +int leBig(VAL x, VAL y); +int geBig(VAL x, VAL y); #endif