File: IExpr.lg

package info (click to toggle)
frown 0.6.1-13
  • links: PTS, VCS
  • area: main
  • in suites: wheezy
  • size: 9,956 kB
  • sloc: haskell: 35,132; makefile: 228; csh: 35; yacc: 23
file content (63 lines) | stat: -rw-r--r-- 2,098 bytes parent folder | download | duplicates (6)
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
The standard example: arithmetic expressions (see dragon book p222).
Missing mutiplication signs are inserted.

	frown --expected IExpr.lg

Try
	expr (lexer "a+b*c+d") :: [Expr]
	expr (lexer "a+b c+d") :: [Expr]

> module IExpr
> where
> import Char
>
> data Expr                     =  Id String
>                               |  Add Expr Expr
>                               |  Mul Expr Expr
>                                  deriving (Show)
>
> type Result                   =  []
>
> %{
>
> Terminal                      =  Ident {String} as "<identifier>"
>                               |  Addop as "+"
>                               |  Mulop as "*"
>                               |  LPar  as "("
>                               |  RPar  as ")";
> 
>*expr {Expr};
> expr {Add e1 e2}              :  expr {e1}, "+", term {e2};
>--      {Add e1 e2}              |  expr {e1}, insert "+", term {e2};
>      {e}                      |  term {e};
>
> term {Expr};
> term {Mul e1 e2}              :  term {e1}, "*", factor {e2};
>      {Mul e1 e2}              |  term {e1}, insert "*", factor {e2};
>      {e}                      |  factor {e};
>
> factor {Expr};
> factor {e}                    :  "(", expr {e}, ")";
>        {Id s}                 |  Ident {s};
>
> }%
>
> frown la ts                   =  fail "syntax error"
> 
> data Terminal                 =  Ident String
>                               |  Addop
>                               |  Mulop
>                               |  LPar
>                               |  RPar
>                                  deriving (Show)
>
> lexer                         :: String -> [Terminal]
> lexer []                      =  []
> lexer ('+' : cs)              =  Addop : lexer cs
> lexer ('*' : cs)              =  Mulop : lexer cs
> lexer ('(' : cs)              =  LPar  : lexer cs
> lexer (')' : cs)              =  RPar  : lexer cs
> lexer (c : cs)
>     | isAlpha c               =  let (n, cs') = span isAlphaNum cs
>                                  in  Ident (c : n) : lexer cs'
>     | otherwise               =  lexer cs