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

SCM Repository

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

Annotation of /trunk/src/compiler/parser/diderot.grm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 435 - (view) (download)

1 : jhr 14 (* diderot.grm
2 :     *
3 : jhr 435 * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 : jhr 14 * All rights reserved.
5 :     *)
6 :    
7 :     %name Diderot;
8 :    
9 :     %tokens
10 :     : KW_actor ("actor")
11 : jhr 25 | KW_bool ("bool")
12 : jhr 39 | KW_D ("D")
13 : jhr 19 | KW_die ("die")
14 : jhr 25 | KW_else ("else")
15 : jhr 14 | KW_field ("field")
16 : jhr 25 | KW_if ("if")
17 : jhr 14 | KW_image ("image")
18 : jhr 25 | KW_input ("input")
19 : jhr 40 | KW_in ("in")
20 :     | KW_initially ("initially")
21 : jhr 25 | KW_int ("int")
22 :     | KW_kernel ("kernel")
23 : jhr 19 | KW_new ("new")
24 : jhr 164 | KW_output ("output")
25 : jhr 25 | KW_real ("real")
26 :     | KW_stabilize ("stabilize")
27 :     | KW_string ("string")
28 :     | KW_tensor ("tensor")
29 : jhr 164 | KW_update ("update")
30 : jhr 48 | KW_vec2 ("vec2")
31 :     | KW_vec3 ("vec3")
32 :     | KW_vec4 ("vec4")
33 : jhr 25 | OP_eq ("=")
34 : jhr 19 | OP_orelse ("||")
35 :     | OP_andalso ("&&")
36 :     | OP_lt ("<")
37 :     | OP_lte ("<=")
38 :     | OP_eqeq ("==")
39 :     | OP_neq ("!=")
40 :     | OP_gte (">=")
41 :     | OP_gt (">")
42 : jhr 14 | OP_plus ("+")
43 :     | OP_minus ("-")
44 :     | OP_star ("*")
45 : jhr 247 | OP_convolve ("(*)")
46 : jhr 19 | OP_slash ("/")
47 : jhr 14 | OP_at ("@")
48 :     | LP ("(")
49 :     | RP (")")
50 :     | LB ("[")
51 :     | RB ("]")
52 :     | LCB ("{")
53 :     | RCB ("}")
54 : jhr 25 | COMMA (",")
55 : jhr 30 | SEMI (";")
56 : jhr 381 | COLON (":")
57 : jhr 25 | HASH ("#")
58 : jhr 26 | BANG ("!")
59 : jhr 40 | BAR ("|")
60 :     | DOTDOT ("..")
61 :     | INT of IntInf.int
62 : jhr 14 | FLOAT of FloatLit.float
63 :     | STRING of string
64 : jhr 19 | ID of Atom.atom
65 : jhr 14 ;
66 :    
67 : jhr 25 %defs (
68 : jhr 27 structure PT = ParseTree
69 :     structure L = Literal
70 : jhr 78 structure B = BasisNames
71 : jhr 27
72 : jhr 25 (* apply a mark constructor to a span and a tree *)
73 :     fun mark cons (span : AntlrStreamPos.span, tr) = cons{span = span, tree = tr}
74 :    
75 : jhr 27 (* specialize mark functions for common node types *)
76 :     val markDecl = mark PT.D_Mark
77 :     fun markTy (_, e as PT.T_Mark _) = e
78 :     | markTy (sp, tr) = mark PT.T_Mark (sp, tr)
79 :     fun markStmt (_, e as PT.S_Mark _) = e
80 :     | markStmt (sp, tr) = mark PT.S_Mark (sp, tr)
81 : jhr 30 fun markExpr (_, e as PT.E_Mark _) = e
82 :     | markExpr (sp, tr) = mark PT.E_Mark (sp, tr)
83 : jhr 27
84 : jhr 79 fun mkCondExp cons = let
85 :     fun mk (e, []) = e
86 :     | mk (e, [e']) = cons(e, e')
87 :     | mk (e, e'::r) = cons(e, mk(e', r))
88 :     in
89 :     mk
90 :     end
91 : jhr 78
92 : jhr 28 (* build an application for an infix binary operator *)
93 :     fun mkBinApp (e1, rator, e2) = PT.E_BinOp(e1, rator, e2)
94 :    
95 :     (* construct application expressions for left-associative binary operators *)
96 :     fun mkLBinExp (e, []) = e
97 :     | mkLBinExp (e, (id, e')::r) = mkLBinExp (mkBinApp(e, id, e'), r)
98 :    
99 :     (* construct application expressions for right-associative binary operators *)
100 :     fun mkRBinExp (e, []) = e
101 :     | mkRBinExp (e, [(id, e')]) = mkBinApp(e, id, e')
102 :     | mkRBinExp (e, (id, e')::r) = mkBinApp(e, id, mkRBinExp(e', r))
103 :    
104 : jhr 381 fun mkOptExp (_, e, NONE) = e
105 :     | mkOptExp (spn, e, SOME mk) = mk(spn, e)
106 :    
107 : jhr 27 fun flatten NONE = []
108 : jhr 30 | flatten (SOME(x, xs)) = x::xs
109 :    
110 : jhr 25 );
111 :    
112 : jhr 14 File
113 : jhr 81 : Decl+ => (PT.Program{span=FULL_SPAN, tree=Decl})
114 : jhr 14 ;
115 :    
116 :     Decl
117 : jhr 23 : InputDecl
118 : jhr 30 | VarDecl => (PT.D_Var VarDecl)
119 : jhr 14 | ActorDecl
120 : jhr 40 | CoordinationDecl
121 : jhr 14 ;
122 :    
123 : jhr 23
124 :     (***** Inputs *****)
125 :    
126 :     InputDecl
127 : jhr 228 : "input" ValueType ID ( "=" Expr )? ";"
128 :     => (markDecl(FULL_SPAN, PT.D_Input(ValueType, ID, SR)))
129 : jhr 14 ;
130 : jhr 19
131 : jhr 27 (***** variable declarations *****)
132 : jhr 19
133 : jhr 27 VarDecl
134 : jhr 23 : Type ID "=" Expr ";"
135 : jhr 27 => (mark PT.VD_Mark (FULL_SPAN, PT.VD_Decl(Type, ID, Expr)))
136 : jhr 23 ;
137 :    
138 :    
139 : jhr 19 (***** Actors *****)
140 :    
141 :     ActorDecl
142 : jhr 164 : "actor" ID "(" Params ")" "{" ActorStateDecl* ActorMethod+ "}"
143 : jhr 27 => (markDecl(FULL_SPAN, PT.D_Actor{
144 : jhr 164 name = ID, params = Params, state = ActorStateDecl,
145 : jhr 27 methods = ActorMethod
146 :     }))
147 : jhr 19 ;
148 :    
149 :     Params
150 :     : ( Param ( "," Param )* )?
151 : jhr 27 => (flatten SR)
152 : jhr 19 ;
153 :    
154 :     Param
155 : jhr 102 : ValueType ID
156 :     => (mark PT.P_Mark (FULL_SPAN, PT.P_Param(ValueType, ID)))
157 : jhr 19 ;
158 :    
159 : jhr 164 ActorStateDecl
160 :     : "output" VarDecl
161 :     => (true, mark PT.VD_Mark (FULL_SPAN, VarDecl))
162 :     | VarDecl
163 :     => (false, VarDecl)
164 :     ;
165 :    
166 : jhr 19 ActorMethod
167 : jhr 164 : MethodId Block
168 :     => (mark PT.M_Mark (FULL_SPAN, PT.M_Method(MethodId, Block)))
169 : jhr 19 ;
170 :    
171 : jhr 164 MethodId
172 :     : "update" => (Atom.atom "update")
173 :     | "stabilize" => (Atom.atom "stabilize")
174 :     | ID => (ID)
175 :     ;
176 :    
177 : jhr 24 Block
178 : jhr 25 : "{" Stmt* "}"
179 :     => (markStmt(FULL_SPAN, PT.S_Block Stmt))
180 : jhr 24 ;
181 : jhr 19
182 : jhr 25 Stmt
183 :     : AtomicStmt
184 :     => (AtomicStmt)
185 :     | %try "if" "(" Expr ")" Stmt "else" Stmt
186 :     => (markStmt(FULL_SPAN, PT.S_IfThenElse(Expr, Stmt1, Stmt2)))
187 :     | %try "if" "(" Expr ")" Stmt
188 :     => (markStmt(FULL_SPAN, PT.S_IfThen(Expr, Stmt)))
189 :     ;
190 :    
191 :     AtomicStmt
192 :     : Block
193 :     => (Block)
194 : jhr 27 | VarDecl
195 :     => (PT.S_Decl VarDecl)
196 : jhr 25 | "stabilize" ";"
197 :     => (markStmt(FULL_SPAN, PT.S_Stabilize))
198 :     | "die" ";"
199 :     => (markStmt(FULL_SPAN, PT.S_Die))
200 :     | "new" ID "(" Arguments ")" ";"
201 :     => (markStmt(FULL_SPAN, PT.S_New(ID, Arguments)))
202 : jhr 24 | ID "=" Expr ";"
203 : jhr 25 => (markStmt(FULL_SPAN, PT.S_Assign(ID, Expr)))
204 : jhr 24 ;
205 :    
206 :     Arguments
207 :     : ( Expr ("," Expr)* )?
208 : jhr 27 => (flatten SR)
209 : jhr 24 ;
210 :    
211 :    
212 : jhr 40 (***** Coordination declaration *****)
213 :    
214 :     CoordinationDecl
215 :     : "initially" (Array | Collection) ";"
216 :     => (markDecl(FULL_SPAN, SR))
217 :     ;
218 :    
219 :     Array
220 :     : "[" Create "|" Iterations "]"
221 :     => (PT.D_InitialArray(Create, Iterations))
222 :     ;
223 :    
224 :     Create
225 :     : ID "(" Arguments ")"
226 :     => (mark PT.C_Mark (FULL_SPAN, PT.C_Create(ID, Arguments)))
227 :     ;
228 :    
229 :     Iterations
230 :     : Iteration ( "," Iteration )+
231 :     => (Iteration :: SR)
232 :     ;
233 :    
234 :     Iteration
235 :     : ID "in" Expr ".." Expr
236 :     => (mark PT.I_Mark (FULL_SPAN, PT.I_Range(ID, Expr1, Expr2)))
237 :     ;
238 :    
239 :     Collection
240 :     : "{" Create "|" Iterations "]"
241 :     => (PT.D_InitialCollection(Create, Iterations))
242 :     ;
243 :    
244 : jhr 19 (***** Types *****)
245 :    
246 : jhr 48 Type : "image" "(" Dimension ")" Dimensions
247 : jhr 39 => (markTy(FULL_SPAN, PT.T_Image{
248 : jhr 70 shape = Dimensions, dim = Dimension
249 : jhr 39 }))
250 : jhr 48 | "field" "#" Dimension "(" Dimension ")" Dimensions
251 : jhr 39 => (markTy(FULL_SPAN, PT.T_Field{
252 :     diff = Dimension1,
253 : jhr 70 shape = Dimensions,
254 : jhr 39 dim = Dimension2
255 :     }))
256 : jhr 23 | "kernel" "#" Dimension
257 : jhr 26 => (markTy(FULL_SPAN, PT.T_Kernel Dimension))
258 : jhr 39 | ValueType ("[" Dimension "]")*
259 :     => (case SR
260 :     of [] => ValueType
261 :     | d => (markTy(FULL_SPAN, PT.T_Array(ValueType, d)))
262 :     (* end case *))
263 : jhr 37 ;
264 :    
265 :     ValueType
266 : jhr 39 : "tensor" Dimensions
267 : jhr 37 => (markTy(FULL_SPAN, PT.T_Tensor Dimensions))
268 : jhr 48 | "vec2"
269 :     => (markTy(FULL_SPAN, PT.T_Vec 2))
270 :     | "vec3"
271 :     => (markTy(FULL_SPAN, PT.T_Vec 3))
272 :     | "vec4"
273 :     => (markTy(FULL_SPAN, PT.T_Vec 4))
274 : jhr 23 | "bool"
275 : jhr 26 => (markTy(FULL_SPAN, PT.T_Bool))
276 : jhr 19 | "int"
277 : jhr 26 => (markTy(FULL_SPAN, PT.T_Int))
278 : jhr 19 | "real"
279 : jhr 26 => (markTy(FULL_SPAN, PT.T_Real))
280 : jhr 24 | "string"
281 : jhr 26 => (markTy(FULL_SPAN, PT.T_String))
282 : jhr 19 ;
283 :    
284 : jhr 24 Dimensions
285 : jhr 48 : "[" ( Dimension ("," Dimension)* )? "]"
286 : jhr 27 => (flatten SR)
287 : jhr 24 ;
288 :    
289 : jhr 23 Dimension
290 : jhr 40 : INT
291 :     => (INT)
292 : jhr 23 ;
293 : jhr 19
294 :     (***** Expressions *****)
295 :    
296 :     Expr
297 : jhr 379 : TestExpr ( "if" Expr "else" Expr => (Expr1, Expr2) )?
298 :     => (case SR
299 :     of NONE => TestExpr
300 :     | SOME(e1, e2) => markExpr(FULL_SPAN, PT.E_Cond(TestExpr, e1, e2))
301 :     (* end case *))
302 :     ;
303 :    
304 :     TestExpr
305 : jhr 79 : AndExpr ( "||" AndExpr )*
306 :     => (mkCondExp PT.E_OrElse (AndExpr, SR))
307 : jhr 19 ;
308 :    
309 : jhr 30 AndExpr
310 : jhr 79 : CmpExpr ( "&&" CmpExpr )*
311 :     => (mkCondExp PT.E_AndAlso (CmpExpr, SR))
312 : jhr 19 ;
313 :    
314 : jhr 30 CmpExpr
315 :     : AddExpr ( CmpOp AddExpr )*
316 :     => (mkLBinExp (AddExpr, SR))
317 : jhr 19 ;
318 :    
319 : jhr 25 CmpOp
320 : jhr 79 : "<" => (B.op_lt) | "<=" => (B.op_lte)
321 :     | "==" => (B.op_equ) | "!=" => (B.op_neq)
322 :     | ">=" => (B.op_gte) | ">" => (B.op_gt)
323 : jhr 19 ;
324 :    
325 : jhr 30 AddExpr
326 :     : MulExpr ( AddOp MulExpr )*
327 :     => (mkLBinExp (MulExpr, SR))
328 : jhr 19 ;
329 :    
330 :     AddOp
331 : jhr 79 : "+" => (B.op_add) | "-" => (B.op_sub)
332 : jhr 19 ;
333 :    
334 : jhr 30 MulExpr
335 : jhr 382 : ProbeExpr ( MulOp ProbeExpr )*
336 :     => (mkLBinExp (ProbeExpr, SR))
337 : jhr 19 ;
338 :    
339 :     MulOp
340 : jhr 247 : "*" => (B.op_mul) | "/" => (B.op_div) | "(*)" => (B.op_convolve)
341 : jhr 19 ;
342 :    
343 : jhr 381 ProbeExpr
344 :     : PrefixExpr ( "@" AtomExpr => (AtomExpr) )?
345 :     => (case SR
346 :     of NONE => PrefixExpr
347 :     | SOME e => markExpr(FULL_SPAN, PT.E_BinOp(PrefixExpr, B.op_at, e))
348 :     (* end case *))
349 :     ;
350 :    
351 : jhr 30 PrefixExpr
352 : jhr 381 : SliceExpr
353 :     => (SliceExpr)
354 : jhr 30 | "-" PrefixExpr
355 : jhr 79 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_neg, PrefixExpr)))
356 : jhr 30 | "!" PrefixExpr
357 : jhr 79 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_not, PrefixExpr)))
358 : jhr 39 | "D" PrefixExpr
359 : jhr 79 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_D, PrefixExpr)))
360 : jhr 25 ;
361 :    
362 : jhr 381 SliceExpr
363 :     : AtomExpr ( "[" Indices "]" )?
364 :     => (case SR
365 :     of NONE => AtomExpr
366 :     | SOME s => markExpr(FULL_SPAN, PT.E_Slice(AtomExpr, s))
367 :     (* end case *))
368 : jhr 39 ;
369 :    
370 : jhr 381 Indices
371 :     : Index ( "," Index )*
372 :     => (Index :: SR)
373 :     ;
374 :    
375 :     Index
376 :     : ":"
377 :     => (NONE)
378 :     | Expr
379 :     => (SOME Expr)
380 :     ;
381 :    
382 :     AtomExpr
383 : jhr 35 : ID ( "(" Arguments ")" )?
384 :     => (case SR
385 :     of NONE => markExpr(FULL_SPAN, PT.E_Var ID)
386 :     | SOME args => markExpr(FULL_SPAN, PT.E_Apply(ID, args))
387 :     (* end case *))
388 : jhr 86 | "real" "(" Expr ")"
389 :     => (markExpr(FULL_SPAN, PT.E_Real Expr))
390 :     | "[" Expr ("," Expr)* "]"
391 :     => (markExpr(FULL_SPAN, PT.E_Cons(Expr::SR)))
392 : jhr 40 | INT
393 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Int INT)))
394 : jhr 19 | FLOAT
395 : jhr 30 => (markExpr(FULL_SPAN, PT.E_Lit(L.Float FLOAT)))
396 : jhr 19 | STRING
397 : jhr 27 => (markExpr(FULL_SPAN, PT.E_Lit(L.String STRING)))
398 : jhr 19 | "(" Expr ("," Expr)* ")"
399 : jhr 27 => (case SR
400 :     of [] => Expr
401 :     | l => markExpr(FULL_SPAN, PT.E_Tuple(Expr::l))
402 :     (* end case *))
403 : jhr 45 | "|" Expr "|"
404 : jhr 82 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_norm, Expr)))
405 : jhr 19 ;

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