Dear all,
Could someone explain me why the following does not work?
Any help is *greatly* appreciated. If I can't find out
what causes this problem, I'll have to program in c and
use yacc & lex for the next 2.5 years :-(
Sincerely,
Marc van Dongen
[EMAIL PROTECTED]
******************************* tmp.ly **********************************************
> {
> module Tmp(happyError) where
> }
> %name test
> %tokentype { Token }
> %token
> var { TokVar }
> %newline { '\n' }
> %%
> Test :: { String }
> Test: { "" }
Test: var { "" } -- also won't work
> {
> happyError :: Int -> [Token] -> a
> happyError i _ = error ("Parse error in line " ++ show i ++ "\n")
> data Token = TokVar
> }
*************************** happying and ghcing *************************************
> happy tmp.ly
> ghc -c tmp.hs
"tmp.hs", line 41:
Couldn't match the type `Token' against `Char'.
Inside two case alternatives:
... TokVar -> cont 2
... '\n' -> happyNewToken action (ln + 1) tks
Compilation had errors
********************************* tmp.hs ********************************************
-- parser produced by Happy Version 0.8
module Tmp(happyError) where
data HappyAbsSyn
= HappyTerminal ( Token )
| HappyAbsSyn1 ( String )
type HappyReduction =
Int
-> ( Token )
-> HappyState ( Token ) ([HappyAbsSyn] -> ( String ))
-> Int
-> [ Token ]
-> [HappyState ( Token ) ([HappyAbsSyn] -> ( String ))]
-> [HappyAbsSyn]
-> ( String )
action_0,
action_1 :: Int -> HappyReduction
happyReduce_1 :: HappyReduction
action_0 1 = happyGoto action_1
action_0 _ = happyReduce_1
action_1 3 = happyAccept
action_1 _ = happyFail
happyReduce_1 = specHappyReduce_0 1 reduction where {
reduction (
happyRest)
happy_var_lineno = HappyAbsSyn1
( "" ) : happyRest}
happyNewToken action ln []
= action 3 3 (error "reading EOF!") (HappyState action) ln []
happyNewToken action ln (tk:tks) = case tk of
TokVar -> cont 2
'\n' -> happyNewToken action (ln + 1) tks
where cont i = action i i tk (HappyState action) ln tks
test = happyParse
happyError :: Int -> [Token] -> a
happyError i _ = error ("Parse error in line " ++ show i ++ "\n")
data Token = TokVar
-- Start of Happy Template (version 0.8)
happyParse tks = happyNewToken action_0 (1::Int) tks [] []
-- All this HappyState stuff is simply because we can't have recursive
-- types in Haskell without an intervening data structure.
data HappyState b c = HappyState
(Int -> -- token number
Int -> -- token number (yes, again)
b -> -- token semantic value
HappyState b c -> -- current state
Int -> -- line number
[b] -> -- rest of tokens
[HappyState b c] -> -- state stack
c)
-- Ok, Here are the action functions.
happyAccept _ _ _ _ _ _ [ HappyAbsSyn1 ans ] = ans
happyFail _ _ _ ln tks _ _ = happyError ln tks
happyShift new_state i tk st ln tks sts stk =
happyNewToken new_state ln tks (st:sts) (HappyTerminal tk:stk)
happyGoto action j tk st = action j j tk (HappyState action)
-- happyReduce is specialised for the common cases.
specHappyReduce_0 i fn j tk st@(HappyState action) ln tks sts stk
= action i j tk st ln tks (st:sts) (fn stk ln)
specHappyReduce_1 i fn j tk _ ln tks sts@(st@(HappyState action):_) stk
= action i j tk st ln tks sts (fn stk ln)
specHappyReduce_2 i fn j tk _ ln tks (_:sts@(st@(HappyState action):_)) stk
= action i j tk st ln tks sts (fn stk ln)
specHappyReduce_3 i fn j tk _ ln tks (_:_:sts@(st@(HappyState action):_)) stk
= action i j tk st ln tks sts (fn stk ln)
happyReduce i k fn j tk st ln tks sts stk
= action i j tk st' ln tks sts' (fn stk ln)
where sts'@(st'@(HappyState action):_) = drop (k::Int) (st:sts)
-- Internal happy errors:
notHappyAtAll :: Int -> a
notHappyAtAll i = error ("Internal Happy error in reduction ( "
++ show i ++ " )")
-- end of Happy Template.
