1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
{
-- We use these options because Happy generates code with a lot of warnings.
{-# OPTIONS_GHC -w #-}
module Text.Show.Parser (parseValue) where
import Text.Show.Value
import Language.Haskell.Lexer
}
%token
'=' { (Reservedop, (_,"=")) }
'(' { (Special, (_,"(")) }
')' { (Special, (_,")")) }
'{' { (Special, (_,"{")) }
'}' { (Special, (_,"}")) }
'[' { (Special, (_,"[")) }
']' { (Special, (_,"]")) }
',' { (Special, (_,",")) }
'-' { (Varsym, (_,"-")) }
'%' { (Varsym, (_,"%")) }
INT { (IntLit, (_,$$)) }
FLOAT { (FloatLit, (_,$$)) }
STRING { (StringLit, (_,$$)) }
CHAR { (CharLit, (_,$$)) }
VARID { (Varid, (_,$$)) }
QVARID { (Qvarid, (_,$$)) }
VARSYM { (Varsym, (_,$$)) }
QVARSYM { (Qvarsym, (_,$$)) }
CONID { (Conid, (_,$$)) }
QCONID { (Qconid, (_,$$)) }
CONSYM { (Consym, (_,$$)) }
QCONSYM { (Qconsym, (_,$$)) }
%monad { Maybe } { (>>=) } { return }
%name parseValue value
%tokentype { PosToken }
%%
value :: { Value }
: value '%' app_value { Ratio $1 $3 }
| '-' avalue { Neg $2 }
| app_value { $1 }
app_value :: { Value }
: con list1(avalue) { Con $1 $2 }
| avalue { $1 }
avalue :: { Value }
: '(' value ')' { $2 }
| '[' sep(value,',') ']' { List $2 }
| '(' tuple ')' { Tuple $2 }
| con '{' sep(field,',') '}' { Rec $1 $3 }
| con { Con $1 [] }
| INT { Integer $1 }
| FLOAT { Float $1 }
| STRING { String $1 }
| CHAR { Char $1 }
con :: { String }
: CONID { $1 }
| QCONID { $1 }
| prefix(CONSYM) { $1 }
| prefix(QCONSYM) { $1 }
-- to support things like "fromList x"
| VARID { $1 }
| QVARID { $1 }
| prefix(VARSYM) { $1 }
| prefix(QVARSYM) { $1 }
field :: { (Name,Value) }
: VARID '=' value { ($1,$3) }
tuple :: { [Value] }
: { [] }
| value ',' sep1(value,',') { $1 : $3 }
-- Common Rule Patterns --------------------------------------------------------
prefix(p) : '(' p ')' { "(" ++ $2 ++ ")" }
sep1(p,q) : p list(snd(q,p)) { $1 : $2 }
sep(p,q) : sep1(p,q) { $1 }
| { [] }
snd(p,q) : p q { $2 }
list1(p) : rev_list1(p) { reverse $1 }
list(p) : list1(p) { $1 }
| { [] }
rev_list1(p) : p { [$1] }
| rev_list1(p) p { $2 : $1 }
{
happyError :: [PosToken] -> Maybe a
happyError ((_,(p,_)) : _) = Nothing -- error ("Parser error at: " ++ show p)
happyError [] = Nothing -- error ("Parser error at EOF")
}
|
