Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/lamont/src/compiler/parser/diderot.grm
ViewVC logotype

Annotation of /branches/lamont/src/compiler/parser/diderot.grm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 37 - (view) (download)
Original Path: trunk/src/parser/diderot.grm

1 : jhr 14 (* diderot.grm
2 :     *
3 :     * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 :     %name Diderot;
8 :    
9 :     %tokens
10 :     : KW_actor ("actor")
11 : jhr 25 | KW_bool ("bool")
12 : jhr 19 | KW_die ("die")
13 : jhr 25 | KW_else ("else")
14 : jhr 14 | KW_field ("field")
15 : jhr 25 | KW_if ("if")
16 : jhr 14 | KW_image ("image")
17 : jhr 25 | KW_input ("input")
18 :     | KW_int ("int")
19 :     | KW_kernel ("kernel")
20 : jhr 19 | KW_new ("new")
21 : jhr 25 | KW_real ("real")
22 :     | KW_stabilize ("stabilize")
23 :     | KW_string ("string")
24 :     | KW_tensor ("tensor")
25 :     | KW_vec ("vec")
26 :     | OP_eq ("=")
27 : jhr 19 | OP_orelse ("||")
28 :     | OP_andalso ("&&")
29 :     | OP_lt ("<")
30 :     | OP_lte ("<=")
31 :     | OP_eqeq ("==")
32 :     | OP_neq ("!=")
33 :     | OP_gte (">=")
34 :     | OP_gt (">")
35 : jhr 14 | OP_plus ("+")
36 :     | OP_minus ("-")
37 :     | OP_star ("*")
38 : jhr 19 | OP_slash ("/")
39 : jhr 14 | OP_at ("@")
40 :     | LP ("(")
41 :     | RP (")")
42 :     | LB ("[")
43 :     | RB ("]")
44 :     | LCB ("{")
45 :     | RCB ("}")
46 : jhr 25 | COMMA (",")
47 : jhr 30 | SEMI (";")
48 : jhr 25 | HASH ("#")
49 : jhr 26 | BANG ("!")
50 : jhr 33 | POSINT of IntInf.int
51 :     | NEGINT of IntInf.int
52 : jhr 14 | FLOAT of FloatLit.float
53 :     | STRING of string
54 : jhr 19 | ID of Atom.atom
55 : jhr 14 ;
56 :    
57 : jhr 25 %defs (
58 : jhr 27 structure PT = ParseTree
59 :     structure L = Literal
60 : jhr 30 structure Op = Operators
61 : jhr 27
62 : jhr 25 (* apply a mark constructor to a span and a tree *)
63 :     fun mark cons (span : AntlrStreamPos.span, tr) = cons{span = span, tree = tr}
64 :    
65 : jhr 27 (* specialize mark functions for common node types *)
66 :     val markDecl = mark PT.D_Mark
67 :     fun markTy (_, e as PT.T_Mark _) = e
68 :     | markTy (sp, tr) = mark PT.T_Mark (sp, tr)
69 :     fun markStmt (_, e as PT.S_Mark _) = e
70 :     | markStmt (sp, tr) = mark PT.S_Mark (sp, tr)
71 : jhr 30 fun markExpr (_, e as PT.E_Mark _) = e
72 :     | markExpr (sp, tr) = mark PT.E_Mark (sp, tr)
73 : jhr 27
74 : jhr 28 (* build an application for an infix binary operator *)
75 :     fun mkBinApp (e1, rator, e2) = PT.E_BinOp(e1, rator, e2)
76 :    
77 :     (* construct application expressions for left-associative binary operators *)
78 :     fun mkLBinExp (e, []) = e
79 :     | mkLBinExp (e, (id, e')::r) = mkLBinExp (mkBinApp(e, id, e'), r)
80 :    
81 :     (* construct application expressions for right-associative binary operators *)
82 :     fun mkRBinExp (e, []) = e
83 :     | mkRBinExp (e, [(id, e')]) = mkBinApp(e, id, e')
84 :     | mkRBinExp (e, (id, e')::r) = mkBinApp(e, id, mkRBinExp(e', r))
85 :    
86 : jhr 27 fun flatten NONE = []
87 : jhr 30 | flatten (SOME(x, xs)) = x::xs
88 :    
89 : jhr 25 );
90 :    
91 : jhr 14 File
92 : jhr 31 : Decl+ => (PT.Program Decl)
93 : jhr 14 ;
94 :    
95 :     Decl
96 : jhr 23 : InputDecl
97 : jhr 30 | VarDecl => (PT.D_Var VarDecl)
98 : jhr 14 | ActorDecl
99 :     ;
100 :    
101 : jhr 23
102 :     (***** Inputs *****)
103 :    
104 :     InputDecl
105 :     : "input" Type ID ( "=" Expr )? ";"
106 : jhr 27 => (markDecl(FULL_SPAN, PT.D_Input(Type, ID, SR)))
107 : jhr 14 ;
108 : jhr 19
109 : jhr 27 (***** variable declarations *****)
110 : jhr 19
111 : jhr 27 VarDecl
112 : jhr 23 : Type ID "=" Expr ";"
113 : jhr 27 => (mark PT.VD_Mark (FULL_SPAN, PT.VD_Decl(Type, ID, Expr)))
114 : jhr 23 ;
115 :    
116 :    
117 : jhr 19 (***** Actors *****)
118 :    
119 :     ActorDecl
120 : jhr 27 : "actor" ID "(" Params ")" "{" VarDecl* ActorMethod+ "}"
121 :     => (markDecl(FULL_SPAN, PT.D_Actor{
122 :     name = ID, params = Params, state = VarDecl,
123 :     methods = ActorMethod
124 :     }))
125 : jhr 19 ;
126 :    
127 :     Params
128 :     : ( Param ( "," Param )* )?
129 : jhr 27 => (flatten SR)
130 : jhr 19 ;
131 :    
132 :     Param
133 :     : Type ID
134 : jhr 27 => (mark PT.P_Mark (FULL_SPAN, PT.P_Param(Type, ID)))
135 : jhr 19 ;
136 :    
137 :     ActorMethod
138 : jhr 24 : ID Block
139 : jhr 30 => (mark PT.M_Mark (FULL_SPAN, PT.M_Method(ID, Block)))
140 : jhr 19 ;
141 :    
142 : jhr 24 Block
143 : jhr 25 : "{" Stmt* "}"
144 :     => (markStmt(FULL_SPAN, PT.S_Block Stmt))
145 : jhr 24 ;
146 : jhr 19
147 : jhr 25 Stmt
148 :     : AtomicStmt
149 :     => (AtomicStmt)
150 :     | %try "if" "(" Expr ")" Stmt "else" Stmt
151 :     => (markStmt(FULL_SPAN, PT.S_IfThenElse(Expr, Stmt1, Stmt2)))
152 :     | %try "if" "(" Expr ")" Stmt
153 :     => (markStmt(FULL_SPAN, PT.S_IfThen(Expr, Stmt)))
154 :     ;
155 :    
156 :     AtomicStmt
157 :     : Block
158 :     => (Block)
159 : jhr 27 | VarDecl
160 :     => (PT.S_Decl VarDecl)
161 : jhr 25 | "stabilize" ";"
162 :     => (markStmt(FULL_SPAN, PT.S_Stabilize))
163 :     | "die" ";"
164 :     => (markStmt(FULL_SPAN, PT.S_Die))
165 :     | "new" ID "(" Arguments ")" ";"
166 :     => (markStmt(FULL_SPAN, PT.S_New(ID, Arguments)))
167 : jhr 24 | ID "=" Expr ";"
168 : jhr 25 => (markStmt(FULL_SPAN, PT.S_Assign(ID, Expr)))
169 : jhr 24 ;
170 :    
171 :     Arguments
172 :     : ( Expr ("," Expr)* )?
173 : jhr 27 => (flatten SR)
174 : jhr 24 ;
175 :    
176 :    
177 : jhr 19 (***** Types *****)
178 :    
179 : jhr 24 Type : "image" "<" Dimensions ">"
180 : jhr 26 => (markTy(FULL_SPAN, PT.T_Image Dimensions))
181 : jhr 24 | "field" "#" Dimension "<" Dimensions ">"
182 : jhr 26 => (markTy(FULL_SPAN, PT.T_Field(Dimension, Dimensions)))
183 : jhr 23 | "kernel" "#" Dimension
184 : jhr 26 => (markTy(FULL_SPAN, PT.T_Kernel Dimension))
185 : jhr 37 | ValueType
186 :     => (ValueType)
187 :     ;
188 :    
189 :     ValueType
190 :     : "tensor" "<" Dimensions ">"
191 :     => (markTy(FULL_SPAN, PT.T_Tensor Dimensions))
192 : jhr 23 | "vec" "<" Dimension ">"
193 : jhr 26 => (markTy(FULL_SPAN, PT.T_Vec Dimension))
194 : jhr 23 | "bool"
195 : jhr 26 => (markTy(FULL_SPAN, PT.T_Bool))
196 : jhr 19 | "int"
197 : jhr 26 => (markTy(FULL_SPAN, PT.T_Int))
198 : jhr 19 | "real"
199 : jhr 26 => (markTy(FULL_SPAN, PT.T_Real))
200 : jhr 24 | "string"
201 : jhr 26 => (markTy(FULL_SPAN, PT.T_String))
202 : jhr 19 ;
203 :    
204 : jhr 24 Dimensions
205 :     : ( Dimension ("," Dimension)* )?
206 : jhr 27 => (flatten SR)
207 : jhr 24 ;
208 :    
209 : jhr 23 Dimension
210 : jhr 33 : POSINT
211 :     => (POSINT)
212 : jhr 23 ;
213 : jhr 19
214 :     (***** Expressions *****)
215 :    
216 :     Expr
217 : jhr 30 : AndExpr ( "||" AndExpr => (Op.orElse, AndExpr) )*
218 :     => (mkLBinExp (AndExpr, SR))
219 : jhr 19 ;
220 :    
221 : jhr 30 AndExpr
222 :     : CmpExpr ( "&&" CmpExpr => (Op.andAlso, CmpExpr) )*
223 :     => (mkLBinExp (CmpExpr, SR))
224 : jhr 19 ;
225 :    
226 : jhr 30 CmpExpr
227 :     : AddExpr ( CmpOp AddExpr )*
228 :     => (mkLBinExp (AddExpr, SR))
229 : jhr 19 ;
230 :    
231 : jhr 25 CmpOp
232 : jhr 30 : "<" => (Op.lt) | "<=" => (Op.lte)
233 :     | "==" => (Op.equ) | "!=" => (Op.neq)
234 :     | ">=" => (Op.gte) | ">" => (Op.gt)
235 : jhr 19 ;
236 :    
237 : jhr 30 AddExpr
238 :     : MulExpr ( AddOp MulExpr )*
239 :     => (mkLBinExp (MulExpr, SR))
240 : jhr 19 ;
241 :    
242 :     AddOp
243 : jhr 30 : "+" => (Op.plus) | "-" => (Op.minus)
244 : jhr 19 ;
245 :    
246 : jhr 30 MulExpr
247 :     : SelExpr ( MulOp SelExpr )*
248 :     => (mkLBinExp (SelExpr, SR))
249 : jhr 19 ;
250 :    
251 :     MulOp
252 : jhr 30 : "*" => (Op.times) | "/" => (Op.divide)
253 : jhr 19 ;
254 :    
255 : jhr 30 SelExpr
256 :     : PrefixExpr ( "@" PrefixExpr => (Op.at, PrefixExpr) | "[" Expr "]" => (Op.sub, Expr) )*
257 :     => (mkRBinExp (PrefixExpr, SR))
258 : jhr 19 ;
259 :    
260 : jhr 30 PrefixExpr
261 : jhr 25 : AtomExp
262 : jhr 27 => (AtomExp)
263 : jhr 30 | "-" PrefixExpr
264 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(Op.uMinus, PrefixExpr)))
265 :     | "!" PrefixExpr
266 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(Op.bNot, PrefixExpr)))
267 : jhr 25 ;
268 :    
269 : jhr 19 AtomExp
270 : jhr 35 : ID ( "(" Arguments ")" )?
271 :     => (case SR
272 :     of NONE => markExpr(FULL_SPAN, PT.E_Var ID)
273 :     | SOME args => markExpr(FULL_SPAN, PT.E_Apply(ID, args))
274 :     (* end case *))
275 : jhr 37 | ValueType "(" Arguments ")"
276 :     => (markExpr(FULL_SPAN, PT.E_Cons(ValueType, Arguments)))
277 : jhr 33 | POSINT
278 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Int POSINT)))
279 :     | NEGINT
280 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Int NEGINT)))
281 : jhr 19 | FLOAT
282 : jhr 30 => (markExpr(FULL_SPAN, PT.E_Lit(L.Float FLOAT)))
283 : jhr 19 | STRING
284 : jhr 27 => (markExpr(FULL_SPAN, PT.E_Lit(L.String STRING)))
285 : jhr 19 | "(" Expr ("," Expr)* ")"
286 : jhr 27 => (case SR
287 :     of [] => Expr
288 :     | l => markExpr(FULL_SPAN, PT.E_Tuple(Expr::l))
289 :     (* end case *))
290 : jhr 19 ;

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0