diff options
Diffstat (limited to 'testsuite/tests/ghci.debugger/HappyTest.hs')
| -rw-r--r-- | testsuite/tests/ghci.debugger/HappyTest.hs | 525 |
1 files changed, 525 insertions, 0 deletions
diff --git a/testsuite/tests/ghci.debugger/HappyTest.hs b/testsuite/tests/ghci.debugger/HappyTest.hs new file mode 100644 index 0000000000..9be54402a9 --- /dev/null +++ b/testsuite/tests/ghci.debugger/HappyTest.hs @@ -0,0 +1,525 @@ +{-# LANGUAGE CPP #-} +import Data.Char +import Data.Array +import GHC.Exts +import System.IO +import System.IO.Unsafe +import Debug.Trace + +-- parser produced by Happy Version 1.16 + +data HappyAbsSyn + = HappyTerminal Token + | HappyErrorToken Int + | HappyAbsSyn4 (Exp) + | HappyAbsSyn5 (Exp1) + | HappyAbsSyn6 (Term) + | HappyAbsSyn7 (Factor) + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\x01\x00\x25\x00\x1e\x00\x1b\x00\x1d\x00\x18\x00\x00\x00\x00\x00\x00\x00\x01\x00\xf8\xff\x03\x00\x03\x00\x03\x00\x03\x00\x20\x00\x01\x00\x18\x00\x18\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x01\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x07\x00\xfe\xff\x1c\x00\x06\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00"# + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\xfa\xff\xf7\xff\xf6\xff\xf5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\xff\xfc\xff\xf8\xff\xf9\xff\xf4\xff\x00\x00\x00\x00\xfe\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x03\x00\x01\x00\x0b\x00\x03\x00\x04\x00\x03\x00\x04\x00\x02\x00\x03\x00\x03\x00\x0a\x00\x02\x00\x0a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x00\x00\x01\x00\x02\x00\x03\x00\x00\x00\x01\x00\x02\x00\x03\x00\x00\x00\x01\x00\x02\x00\x03\x00\x02\x00\x03\x00\x08\x00\x09\x00\x04\x00\x06\x00\x07\x00\x05\x00\x01\x00\x0c\x00\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\x13\x00\x03\x00\x16\x00\x08\x00\x09\x00\x08\x00\x09\x00\x11\x00\x06\x00\x14\x00\x0a\x00\x18\x00\x0a\x00\x18\x00\x04\x00\x05\x00\x06\x00\x16\x00\x04\x00\x05\x00\x06\x00\x0a\x00\x04\x00\x05\x00\x06\x00\x03\x00\x04\x00\x05\x00\x06\x00\x12\x00\x06\x00\x0c\x00\x0d\x00\x10\x00\x0e\x00\x0f\x00\x11\x00\x03\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = array (1, 11) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (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) + ] + +happy_n_terms = 13 :: Int +happy_n_nonterms = 4 :: Int + +happyReduce_1 = happyReduce 6# 0# happyReduction_1 +happyReduction_1 ((HappyAbsSyn4 happy_var_6) `HappyStk` + _ `HappyStk` + (HappyAbsSyn4 happy_var_4) `HappyStk` + _ `HappyStk` + (HappyTerminal (TokenVar happy_var_2)) `HappyStk` + _ `HappyStk` + happyRest) + = HappyAbsSyn4 + (Let happy_var_2 happy_var_4 happy_var_6 + ) `HappyStk` happyRest + +happyReduce_2 = happySpecReduce_1 0# happyReduction_2 +happyReduction_2 (HappyAbsSyn5 happy_var_1) + = HappyAbsSyn4 + (Exp1 happy_var_1 + ) +happyReduction_2 _ = notHappyAtAll + +happyReduce_3 = happySpecReduce_3 1# happyReduction_3 +happyReduction_3 (HappyAbsSyn6 happy_var_3) + _ + (HappyAbsSyn5 happy_var_1) + = HappyAbsSyn5 + (Plus happy_var_1 happy_var_3 + ) +happyReduction_3 _ _ _ = notHappyAtAll + +happyReduce_4 = happySpecReduce_3 1# happyReduction_4 +happyReduction_4 (HappyAbsSyn6 happy_var_3) + _ + (HappyAbsSyn5 happy_var_1) + = HappyAbsSyn5 + (Minus happy_var_1 happy_var_3 + ) +happyReduction_4 _ _ _ = notHappyAtAll + +happyReduce_5 = happySpecReduce_1 1# happyReduction_5 +happyReduction_5 (HappyAbsSyn6 happy_var_1) + = HappyAbsSyn5 + (Term happy_var_1 + ) +happyReduction_5 _ = notHappyAtAll + +happyReduce_6 = happySpecReduce_3 2# happyReduction_6 +happyReduction_6 (HappyAbsSyn7 happy_var_3) + _ + (HappyAbsSyn6 happy_var_1) + = HappyAbsSyn6 + (Times happy_var_1 happy_var_3 + ) +happyReduction_6 _ _ _ = notHappyAtAll + +happyReduce_7 = happySpecReduce_3 2# happyReduction_7 +happyReduction_7 (HappyAbsSyn7 happy_var_3) + _ + (HappyAbsSyn6 happy_var_1) + = HappyAbsSyn6 + (Div happy_var_1 happy_var_3 + ) +happyReduction_7 _ _ _ = notHappyAtAll + +happyReduce_8 = happySpecReduce_1 2# happyReduction_8 +happyReduction_8 (HappyAbsSyn7 happy_var_1) + = HappyAbsSyn6 + (Factor happy_var_1 + ) +happyReduction_8 _ = notHappyAtAll + +happyReduce_9 = happySpecReduce_1 3# happyReduction_9 +happyReduction_9 (HappyTerminal (TokenInt happy_var_1)) + = HappyAbsSyn7 + (Int happy_var_1 + ) +happyReduction_9 _ = notHappyAtAll + +happyReduce_10 = happySpecReduce_1 3# happyReduction_10 +happyReduction_10 (HappyTerminal (TokenVar happy_var_1)) + = HappyAbsSyn7 + (Var happy_var_1 + ) +happyReduction_10 _ = notHappyAtAll + +happyReduce_11 = happySpecReduce_3 3# happyReduction_11 +happyReduction_11 _ + (HappyAbsSyn4 happy_var_2) + _ + = HappyAbsSyn7 + (Brack happy_var_2 + ) +happyReduction_11 _ _ _ = notHappyAtAll + +happyNewToken action sts stk [] = + happyDoAction 12# notHappyAtAll action sts stk [] + +happyNewToken action sts stk (tk:tks) = + let cont i = happyDoAction i tk action sts stk tks in + case tk of { + TokenLet -> cont 1#; + TokenIn -> cont 2#; + TokenInt happy_dollar_dollar -> cont 3#; + TokenVar happy_dollar_dollar -> cont 4#; + TokenEq -> cont 5#; + TokenPlus -> cont 6#; + TokenMinus -> cont 7#; + TokenTimes -> cont 8#; + TokenDiv -> cont 9#; + TokenOB -> cont 10#; + TokenCB -> cont 11#; + _ -> happyError' (tk:tks) + } + +happyError_ tk tks = happyError' (tk:tks) + +newtype HappyIdentity a = HappyIdentity a +happyIdentity = HappyIdentity +happyRunIdentity (HappyIdentity a) = a + +instance Monad HappyIdentity where + return = HappyIdentity + (HappyIdentity p) >>= q = q p + +happyThen :: () => HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b +happyThen = (>>=) +happyReturn :: () => a -> HappyIdentity a +happyReturn = (return) +happyThen1 m k tks = (>>=) m (\a -> k a tks) +happyReturn1 :: () => a -> b -> HappyIdentity a +happyReturn1 = \a tks -> (return) a +happyError' :: () => [Token] -> HappyIdentity a +happyError' = HappyIdentity . happyError + +calc tks = happyRunIdentity happySomeParser where + happySomeParser = happyThen (happyParse 0# tks) (\x -> case x of {HappyAbsSyn4 z -> happyReturn z; _other -> notHappyAtAll }) + +happySeq = happyDontSeq + + +happyError tks = error "Parse error" + + + +data Exp = Let String Exp Exp | Exp1 Exp1 +data Exp1 = Plus Exp1 Term | Minus Exp1 Term | Term Term +data Term = Times Term Factor | Div Term Factor | Factor Factor +data Factor = Int Int | Var String | Brack Exp + + + +data Token + = TokenLet + | TokenIn + | TokenInt Int + | TokenVar String + | TokenEq + | TokenPlus + | TokenMinus + | TokenTimes + | TokenDiv + | TokenOB + | TokenCB + + + +lexer :: String -> [Token] +lexer [] = [] +lexer (c:cs) + | isSpace c = lexer cs + | isAlpha c = lexVar (c:cs) + | isDigit c = lexNum (c:cs) +lexer ('=':cs) = TokenEq : lexer cs +lexer ('+':cs) = TokenPlus : lexer cs +lexer ('-':cs) = TokenMinus : lexer cs +lexer ('*':cs) = TokenTimes : lexer cs +lexer ('/':cs) = TokenDiv : lexer cs +lexer ('(':cs) = TokenOB : lexer cs +lexer (')':cs) = TokenCB : lexer cs + +lexNum cs = TokenInt (read num) : lexer rest + where (num,rest) = span isDigit cs + +lexVar cs = + case span isAlpha cs of + ("let",rest) -> TokenLet : lexer rest + ("in",rest) -> TokenIn : lexer rest + (var,rest) -> TokenVar var : lexer rest + + + + +runCalc :: String -> Exp +runCalc = calc . lexer + + + +main = case runCalc "1 + 2 + 3" of { + (Exp1 (Plus (Plus (Term (Factor (Int 1))) (Factor (Int 2))) (Factor (Int 3)))) -> + case runCalc "1 * 2 + 3" of { + (Exp1 (Plus (Term (Times (Factor (Int 1)) (Int 2))) (Factor (Int 3)))) -> + case runCalc "1 + 2 * 3" of { + (Exp1 (Plus (Term (Factor (Int 1))) (Times (Factor (Int 2)) (Int 3)))) -> + case runCalc "let x = 2 in x * (x - 2)" of { + (Let "x" (Exp1 (Term (Factor (Int 2)))) (Exp1 (Term (Times (Factor (Var "x")) (Brack (Exp1 (Minus (Term (Factor (Var "x"))) (Factor (Int 2))))))))) -> print "Test works\n"; + _ -> quit } ; _ -> quit } ; _ -> quit } ; _ -> quit } +quit = print "Test failed\n" +{-# LINE 1 "GenericTemplate.hs" #-} +{-# LINE 1 "<built-in>" #-} +{-# LINE 1 "<command line>" #-} +{-# LINE 1 "GenericTemplate.hs" #-} +-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp + +{-# LINE 28 "GenericTemplate.hs" #-} + + +data Happy_IntList = HappyCons Int# Happy_IntList + + + + + +{-# LINE 49 "GenericTemplate.hs" #-} + +{-# LINE 59 "GenericTemplate.hs" #-} + + + +happyTrace string expr = unsafePerformIO $ do + hPutStr stderr string + return expr + + + + +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 + = (happyTrace ("state: " ++ show (I# (st)) ++ ",\ttoken: " ++ show (I# (i)) ++ ",\taction: ")) $ + + + case action of + 0# -> (happyTrace ("fail.\n")) $ + happyFail i tk st + -1# -> (happyTrace ("accept.\n")) $ + happyAccept i tk st + n | (n <# (0# :: Int#)) -> (happyTrace ("reduce (rule " ++ show rule ++ ")")) $ + + (happyReduceArr ! rule) i tk st + where rule = (I# ((negateInt# ((n +# (1# :: Int#)))))) + n -> (happyTrace ("shift, enter state " ++ show (I# (new_state)) ++ "\n")) $ + + + happyShift new_state i tk st + where new_state = (n -# (1# :: Int#)) + where off = indexShortOffAddr happyActOffsets st + off_i = (off +# i) + check = if (off_i >=# (0# :: Int#)) + then (indexShortOffAddr happyCheck off_i ==# i) + else False + action | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + +{-# LINE 127 "GenericTemplate.hs" #-} + + +indexShortOffAddr (HappyA# arr) off = +#if __GLASGOW_HASKELL__ > 500 + narrow16Int# i +#elif __GLASGOW_HASKELL__ == 500 + intToInt16# i +#else + (i `iShiftL#` 16#) `iShiftRA#` 16# +#endif + where +#if __GLASGOW_HASKELL__ >= 503 + i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low) +#else + i = word2Int# ((high `shiftL#` 8#) `or#` low) +#endif + high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#))) + low = int2Word# (ord# (indexCharOffAddr# arr off')) + off' = off *# 2# + + + + + +data HappyAddr = HappyA# Addr# + + + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + +{-# LINE 170 "GenericTemplate.hs" #-} + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case x of { HappyErrorToken (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)) ((HappyTerminal (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 -# (1# :: 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 +# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n -# (1# :: Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n -# (1#::Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + (happyTrace (", goto state " ++ show (I# (new_state)) ++ "\n")) $ + happyDoAction j tk new_state + where off = indexShortOffAddr happyGotoOffsets st + off_i = (off +# 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 ( (HappyErrorToken (I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: 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. |