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 2308 - (view) (download)

1 : jhr 14 (* diderot.grm
2 :     *
3 : jhr 1116 * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 : jhr 14 * All rights reserved.
5 :     *)
6 :    
7 :     %name Diderot;
8 :    
9 :     %tokens
10 : jhr 2264 : KW_active ("active")
11 :     | KW_all ("all")
12 :     | KW_bool ("bool")
13 :     | KW_dead ("dead")
14 :     | KW_die ("die")
15 :     | KW_else ("else")
16 :     | KW_exists ("exists")
17 :     | KW_false ("false")
18 :     | KW_field ("field")
19 :     | KW_foreach ("foreach")
20 : jhr 2298 | KW_function ("function")
21 : jhr 2264 | KW_global ("global")
22 :     | KW_identity ("identity") (* identity matrix *)
23 :     | KW_if ("if")
24 :     | KW_image ("image")
25 :     | KW_input ("input")
26 :     | KW_in ("in")
27 :     | KW_initially ("initially")
28 :     | KW_int ("int")
29 :     | KW_kernel ("kernel")
30 :     | KW_load ("load")
31 :     | KW_new ("new")
32 : jhr 2298 | KW_max ("maxr") (* FIXME: should overload "max" *)
33 : jhr 2264 | KW_mean ("mean")
34 : jhr 2298 | KW_min ("minr") (* FIXME: should overload "min" *)
35 : jhr 2264 | KW_product ("product")
36 :     | KW_output ("output")
37 :     | KW_print ("print")
38 :     | KW_real ("real")
39 : jhr 2298 | KW_return ("return")
40 : jhr 2264 | KW_stabilize ("stabilize")
41 :     | KW_stable ("stable")
42 :     | KW_strand ("strand")
43 :     | KW_string ("string")
44 :     | KW_sum ("sum")
45 :     | KW_tensor ("tensor")
46 :     | KW_true ("true")
47 :     | KW_update ("update")
48 :     | KW_variance ("variance")
49 :     | KW_vec2 ("vec2")
50 :     | KW_vec3 ("vec3")
51 :     | KW_vec4 ("vec4")
52 :     | KW_xor ("xor")
53 :     | KW_zeros ("zeros") (* zero tensor *)
54 :     | OP_eq ("=")
55 :     | OP_pluseq ("+=")
56 :     | OP_minuseq ("-=")
57 :     | OP_stareq ("*=")
58 :     | OP_slasheq ("/=")
59 :     | OP_orelse ("||")
60 :     | OP_andalso ("&&")
61 :     | OP_lt ("<")
62 :     | OP_lte ("<=")
63 :     | OP_eqeq ("==")
64 :     | OP_neq ("!=")
65 :     | OP_gte (">=")
66 :     | OP_gt (">")
67 :     | OP_plus ("+")
68 :     | OP_minus ("-")
69 :     | OP_star ("*")
70 :     | OP_convolve ("⊛")
71 :     | OP_dot ("•")
72 :     | OP_dotSelect (".")
73 :     | OP_cross ("×")
74 :     | OP_outer ("⊗")
75 :     | OP_slash ("/")
76 :     | OP_exp ("^")
77 :     | OP_at ("@")
78 :     | OP_D ("∇")
79 :     | OP_Dotimes ("∇⊗")
80 :     | OP_curl ("∇×")
81 :     | OP_Ddot ("∇•")
82 :     | LP ("(")
83 :     | RP (")")
84 :     | LB ("[")
85 :     | RB ("]")
86 :     | LCB ("{")
87 :     | RCB ("}")
88 :     | COMMA (",")
89 :     | SEMI (";")
90 :     | COLON (":")
91 :     | HASH ("#")
92 :     | BANG ("!")
93 :     | BAR ("|")
94 :     | DOTDOT ("..")
95 : jhr 40 | INT of IntInf.int
96 : jhr 14 | FLOAT of FloatLit.float
97 :     | STRING of string
98 : jhr 19 | ID of Atom.atom
99 : jhr 14 ;
100 :    
101 : jhr 1116 %keywords
102 : jhr 2308 KW_active, KW_all, KW_bool, KW_dead, KW_die, KW_else, KW_field, KW_foreach, KW_function, KW_identity, KW_if, KW_global, KW_image, KW_initially,
103 : jhr 2298 KW_int, KW_kernel, KW_load, KW_max, KW_min, KW_mean, KW_new,KW_exists, KW_output, KW_real, KW_print,KW_product, KW_return, KW_stable, KW_stabilize,KW_sum,
104 : lamonts 2203 KW_strand, KW_string, KW_tensor, KW_update, KW_variance, KW_vec2, KW_vec3, KW_vec4,KW_xor, KW_zeros;
105 : jhr 1116
106 : jhr 25 %defs (
107 : jhr 27 structure PT = ParseTree
108 :     structure L = Literal
109 : jhr 78 structure B = BasisNames
110 : jhr 27
111 : jhr 25 (* apply a mark constructor to a span and a tree *)
112 :     fun mark cons (span : AntlrStreamPos.span, tr) = cons{span = span, tree = tr}
113 :    
114 : jhr 27 (* specialize mark functions for common node types *)
115 :     val markDecl = mark PT.D_Mark
116 :     fun markTy (_, e as PT.T_Mark _) = e
117 :     | markTy (sp, tr) = mark PT.T_Mark (sp, tr)
118 :     fun markStmt (_, e as PT.S_Mark _) = e
119 :     | markStmt (sp, tr) = mark PT.S_Mark (sp, tr)
120 : jhr 30 fun markExpr (_, e as PT.E_Mark _) = e
121 :     | markExpr (sp, tr) = mark PT.E_Mark (sp, tr)
122 : jhr 27
123 : jhr 79 fun mkCondExp cons = let
124 : jhr 2264 fun mk (e, []) = e
125 :     | mk (e, [e']) = cons(e, e')
126 :     | mk (e, e'::r) = cons(e, mk(e', r))
127 :     in
128 :     mk
129 :     end
130 : jhr 78
131 : jhr 28 (* build an application for an infix binary operator *)
132 :     fun mkBinApp (e1, rator, e2) = PT.E_BinOp(e1, rator, e2)
133 :    
134 :     (* construct application expressions for left-associative binary operators *)
135 :     fun mkLBinExp (e, []) = e
136 :     | mkLBinExp (e, (id, e')::r) = mkLBinExp (mkBinApp(e, id, e'), r)
137 :    
138 :     (* construct application expressions for right-associative binary operators *)
139 :     fun mkRBinExp (e, []) = e
140 :     | mkRBinExp (e, [(id, e')]) = mkBinApp(e, id, e')
141 :     | mkRBinExp (e, (id, e')::r) = mkBinApp(e, id, mkRBinExp(e', r))
142 :    
143 : jhr 381 fun mkOptExp (_, e, NONE) = e
144 :     | mkOptExp (spn, e, SOME mk) = mk(spn, e)
145 :    
146 : jhr 27 fun flatten NONE = []
147 : jhr 30 | flatten (SOME(x, xs)) = x::xs
148 :    
149 : jhr 25 );
150 :    
151 : jhr 14 File
152 : jhr 2298 (* FIXME: GlobalBlock should be combined with the CoordinationDecl *)
153 : jhr 2264 : GlobalDecl* StrandDecl GlobalBlock CoordinationDecl
154 :     => (PT.Program{
155 :     span = FULL_SPAN,
156 :     tree = GlobalDecl @ (StrandDecl :: CoordinationDecl :: GlobalBlock)
157 :     })
158 :     ;
159 : jhr 14
160 : jhr 1926 GlobalDecl
161 : jhr 2264 : InputDecl
162 :     | VarDecl
163 :     => (mark PT.D_Mark (FULL_SPAN, PT.D_Var VarDecl))
164 : jhr 2298 | FunDecl
165 : jhr 2264 ;
166 : jhr 14
167 : jhr 2264
168 : jhr 23 (***** Inputs *****)
169 :    
170 :     InputDecl
171 : jhr 2264 : "input" InputType ID ("(" STRING ")")? ( "=" Initializer )? ";"
172 :     => (markDecl(FULL_SPAN, PT.D_Input(InputType, ID, SR1, SR2)))
173 :     ;
174 : jhr 19
175 :    
176 : jhr 2264 (***** Variable declarations *****)
177 :    
178 : lamonts 2083 VarIterationDecl
179 : jhr 2264 : Type ID "in" Expr
180 :     => (mark PT.VD_Mark (FULL_SPAN, PT.VD_Decl(PT.T_DynSeq(Type), ID, Expr)))
181 :     ;
182 :    
183 : jhr 27 VarDecl
184 : jhr 2264 : Type ID "=" Expr ";"
185 :     => (mark PT.VD_Mark (FULL_SPAN, PT.VD_Decl(Type, ID, Expr)))
186 :     ;
187 : jhr 23
188 :    
189 : jhr 2298 (***** Function declarations *****)
190 : jhr 19
191 : jhr 2298 FunDecl
192 :     : "function" ConcreteType ID "(" Params ")" FunBody
193 :     => (markDecl(FULL_SPAN, PT.D_Func(ConcreteType, ID, Params, FunBody)))
194 : jhr 2264 ;
195 : jhr 19
196 :     Params
197 : jhr 2264 : ( Param ( "," Param )* )?
198 :     => (flatten SR)
199 :     ;
200 : jhr 19
201 :     Param
202 : jhr 2264 : ValueType ID
203 :     => (mark PT.P_Mark (FULL_SPAN, PT.P_Param(ValueType, ID)))
204 :     ;
205 : jhr 19
206 : jhr 2298 FunBody
207 :     : "=" Expr ";"
208 :     => (PT.FB_Expr Expr)
209 :     | Block
210 :     => (PT.FB_Stmt Block)
211 :     ;
212 :    
213 :    
214 :     (***** Strands *****)
215 :    
216 :     StrandDecl
217 :     : "strand" ID "(" Params ")" "{" StrandStateDecl* StrandMethod+ "}"
218 :     => (markDecl(FULL_SPAN, PT.D_Strand{
219 :     name = ID, params = Params, state = StrandStateDecl,
220 :     methods = StrandMethod
221 :     }))
222 :     ;
223 :    
224 : jhr 511 StrandStateDecl
225 : jhr 2264 : "output" VarDecl
226 :     => (true, mark PT.VD_Mark (FULL_SPAN, VarDecl))
227 :     | VarDecl
228 :     => (false, VarDecl)
229 :     ;
230 : jhr 164
231 : jhr 511 StrandMethod
232 : jhr 2264 : MethodId Block
233 :     => (mark PT.M_Mark (FULL_SPAN, PT.M_Method(MethodId, Block)))
234 :     ;
235 : jhr 19
236 : jhr 164 MethodId
237 : jhr 2264 : "update" => (StrandUtil.Update)
238 :     | "stabilize" => (StrandUtil.Stabilize)
239 :     ;
240 : jhr 164
241 : jhr 24 Block
242 : jhr 2264 : "{" Stmt* "}"
243 :     => (markStmt(FULL_SPAN, PT.S_Block Stmt))
244 :     ;
245 : jhr 19
246 : jhr 25 Stmt
247 : jhr 2264 : AtomicStmt
248 :     => (AtomicStmt)
249 :     | %try "foreach" "(" VarIterationDecl ")" Stmt
250 :     => (markStmt(FULL_SPAN, PT.S_Foreach(VarIterationDecl,Stmt)))
251 :     | %try "if" "(" Expr ")" Stmt "else" Stmt
252 :     => (markStmt(FULL_SPAN, PT.S_IfThenElse(Expr, Stmt1, Stmt2)))
253 :     | %try "if" "(" Expr ")" Stmt
254 :     => (markStmt(FULL_SPAN, PT.S_IfThen(Expr, Stmt)))
255 :     ;
256 : jhr 25
257 :     AtomicStmt
258 : jhr 2264 : Block
259 :     => (Block)
260 :     | VarDecl
261 :     => (PT.S_Decl VarDecl)
262 :     | "stabilize" ";"
263 :     => (markStmt(FULL_SPAN, PT.S_Stabilize))
264 :     | "die" ";"
265 :     => (markStmt(FULL_SPAN, PT.S_Die))
266 :     | "new" ID "(" Arguments ")" ";"
267 :     => (markStmt(FULL_SPAN, PT.S_New(ID, Arguments)))
268 : jhr 1640 | "print" "(" Expr ("," Expr)* ")" ";"
269 :     => (markStmt(FULL_SPAN, PT.S_Print(Expr::SR)))
270 : jhr 2264 | ID "=" Expr ";"
271 :     => (markStmt(FULL_SPAN, PT.S_Assign(ID, Expr)))
272 :     | ID "+=" Expr ";"
273 :     => (markStmt(FULL_SPAN, PT.S_OpAssign(ID, B.asgn_add, Expr)))
274 :     | ID "-=" Expr ";"
275 :     => (markStmt(FULL_SPAN, PT.S_OpAssign(ID, B.asgn_sub, Expr)))
276 :     | ID "*=" Expr ";"
277 :     => (markStmt(FULL_SPAN, PT.S_OpAssign(ID, B.asgn_mul, Expr)))
278 :     | ID "/=" Expr ";"
279 :     => (markStmt(FULL_SPAN, PT.S_OpAssign(ID, B.asgn_div, Expr)))
280 : jhr 2298 | "return" Expr ";"
281 :     => (markStmt(FULL_SPAN, PT.S_Return Expr))
282 : jhr 2264 ;
283 : jhr 24
284 :     Arguments
285 : jhr 2264 : ( Expr ("," Expr)* )?
286 :     => (flatten SR)
287 :     ;
288 : jhr 24
289 : jhr 2264
290 : lamonts 2095 (***** Strand Sets *****)
291 : jhr 24
292 : lamonts 2095 StrandSetType
293 : jhr 2264 : "all"
294 :     => (mark PT.SS_Mark (FULL_SPAN, PT.SS_All))
295 :     | "active"
296 :     => (mark PT.SS_Mark (FULL_SPAN, PT.SS_Active))
297 :     | "stable"
298 :     => (mark PT.SS_Mark (FULL_SPAN, PT.SS_Stable))
299 :     ;
300 :    
301 : lamonts 2095 StrandSetVar
302 : jhr 2264 : Expr "|" ID "in" Type "." StrandSetType ( "," Type "." StrandSetType)*
303 :     => (mark PT.VD_Mark (FULL_SPAN, PT.VD_SDecl(ID,(Type,StrandSetType)::SR,Expr)))
304 :     ;
305 : lamonts 2095
306 : lamonts 2203
307 : jhr 40 (***** Coordination declaration *****)
308 :    
309 :     CoordinationDecl
310 : jhr 2264 : "initially" (Array | Collection) ";"
311 :     => (markDecl(FULL_SPAN, SR))
312 :     ;
313 : jhr 40
314 :     Array
315 : jhr 2264 : "[" Create "|" Iterations "]"
316 :     => (PT.D_InitialArray(Create, Iterations))
317 :     ;
318 : jhr 40
319 :     Create
320 : jhr 2264 : ID "(" Arguments ")"
321 :     => (mark PT.C_Mark (FULL_SPAN, PT.C_Create(ID, Arguments)))
322 :     ;
323 : jhr 40
324 :     Iterations
325 : jhr 2264 : Iteration ( "," Iteration )*
326 :     => (Iteration :: SR)
327 :     ;
328 : jhr 40
329 :     Iteration
330 : jhr 2264 : ID "in" Expr ".." Expr
331 :     => (mark PT.I_Mark (FULL_SPAN, PT.I_Range(ID, Expr1, Expr2)))
332 :     ;
333 : jhr 40
334 :     Collection
335 : jhr 2264 : "{" Create "|" Iterations "}"
336 :     => (PT.D_InitialCollection(Create, Iterations))
337 :     ;
338 : jhr 40
339 : lamonts 2203
340 :     (****** Global Block *******)
341 :    
342 : jhr 2264 GlobalBlock
343 :     : (* empty *)
344 :     => ([])
345 :     | "global" Block
346 :     => ([markDecl(FULL_SPAN, PT.D_Global Block)])
347 :     ;
348 :    
349 :    
350 : jhr 19 (***** Types *****)
351 :    
352 : jhr 2264 Type : "image" "(" Dimension ")" Dimensions
353 :     => (markTy(FULL_SPAN, PT.T_Image{
354 :     shape = Dimensions, dim = Dimension
355 :     }))
356 :     | "field" "#" Dimension "(" Dimension ")" Dimensions
357 :     => (markTy(FULL_SPAN, PT.T_Field{
358 :     diff = Dimension1,
359 :     shape = Dimensions,
360 :     dim = Dimension2
361 :     }))
362 :     | "kernel" "#" Dimension
363 :     => (markTy(FULL_SPAN, PT.T_Kernel Dimension))
364 : jhr 2298 | ConcreteType
365 :     ;
366 :    
367 :     ConcreteType
368 :     : ValueType SeqDimensions
369 : jhr 2264 => (markTy(FULL_SPAN, SeqDimensions ValueType))
370 :     ;
371 : jhr 37
372 : jhr 1687 SeqDimensions
373 :     : (* empty *)
374 :     => (fn ty => ty)
375 :     | "{" "}"
376 :     => (fn ty => PT.T_DynSeq ty)
377 :     | "{" Dimension "}" SeqDimensions
378 :     => (fn ty => SeqDimensions(PT.T_Seq(ty, Dimension)))
379 :     ;
380 :    
381 : jhr 1926 InputType
382 : jhr 2264 : "image" "(" Dimension ")" Dimensions
383 :     => (markTy(FULL_SPAN, PT.T_Image{
384 :     shape = Dimensions, dim = Dimension
385 :     }))
386 :     | ValueType SeqDimensions
387 :     => (markTy(FULL_SPAN, SeqDimensions ValueType))
388 :     ;
389 : jhr 1926
390 : jhr 37 ValueType
391 : jhr 2264 : "tensor" Dimensions
392 :     => (markTy(FULL_SPAN, PT.T_Tensor Dimensions))
393 :     | "vec2"
394 :     => (markTy(FULL_SPAN, PT.T_Vec 2))
395 :     | "vec3"
396 :     => (markTy(FULL_SPAN, PT.T_Vec 3))
397 :     | "vec4"
398 :     => (markTy(FULL_SPAN, PT.T_Vec 4))
399 :     | "bool"
400 :     => (markTy(FULL_SPAN, PT.T_Bool))
401 :     | "int"
402 :     => (markTy(FULL_SPAN, PT.T_Int))
403 :     | "real"
404 :     => (markTy(FULL_SPAN, PT.T_Real))
405 :     | "string"
406 :     => (markTy(FULL_SPAN, PT.T_String))
407 :     | ID
408 :     => (markTy(FULL_SPAN, PT.T_Strand ID))
409 :     ;
410 : jhr 19
411 : jhr 24 Dimensions
412 : jhr 2264 : "[" ( Dimension ("," Dimension)* )? "]"
413 :     => (flatten SR)
414 :     ;
415 : jhr 24
416 : jhr 23 Dimension
417 : jhr 2264 : INT
418 :     => (INT)
419 :     ;
420 : jhr 19
421 :     (***** Expressions *****)
422 :    
423 :     Expr
424 : jhr 2264 : TestExpr ( "if" Expr "else" Expr => (Expr1, Expr2) )?
425 :     => (case SR
426 :     of NONE => TestExpr
427 :     | SOME(e1, e2) => markExpr(FULL_SPAN, PT.E_Cond(TestExpr, e1, e2))
428 :     (* end case *))
429 :     ;
430 : jhr 379
431 :     TestExpr
432 : jhr 2264 : AndExpr ( "||" AndExpr )*
433 :     => (mkCondExp PT.E_OrElse (AndExpr, SR))
434 :     ;
435 : jhr 19
436 : jhr 30 AndExpr
437 : jhr 2264 : CmpExpr ( "&&" CmpExpr )*
438 :     => (mkCondExp PT.E_AndAlso (CmpExpr, SR))
439 :     ;
440 : jhr 19
441 : jhr 30 CmpExpr
442 : jhr 2264 : AddExpr ( CmpOp AddExpr )*
443 :     => (mkLBinExp (AddExpr, SR))
444 :     ;
445 : jhr 19
446 : jhr 25 CmpOp
447 : jhr 2264 : "<" => (B.op_lt) | "<=" => (B.op_lte)
448 :     | "==" => (B.op_equ) | "!=" => (B.op_neq)
449 :     | ">=" => (B.op_gte) | ">" => (B.op_gt)
450 :     ;
451 : jhr 19
452 : jhr 30 AddExpr
453 : jhr 2264 : MulExpr ( AddOp MulExpr )*
454 :     => (mkLBinExp (MulExpr, SR))
455 :     ;
456 : jhr 19
457 :     AddOp
458 : jhr 2264 : "+" => (B.op_add) | "-" => (B.op_sub) | "@" => (B.op_at)
459 :     ;
460 : jhr 19
461 : jhr 30 MulExpr
462 : jhr 2264 : PowerExpr ( MulOp PowerExpr )*
463 :     => (mkLBinExp (PowerExpr, SR))
464 :     ;
465 : jhr 19
466 :     MulOp
467 : jhr 2264 : "*" => (B.op_mul) | "/" => (B.op_div) | "⊛" => (B.op_convolve)
468 :     | "•" => (B.op_dot) | "×" => (B.op_cross) | "⊗" => (B.op_outer)
469 :     | ":" => (B.op_colon)
470 :     ;
471 : jhr 19
472 : jhr 1116 PowerExpr
473 : jhr 2264 : PrefixExpr ( "^" PrefixExpr => (B.op_exp, PrefixExpr) )*
474 :     => (mkLBinExp (PrefixExpr, SR))
475 :     ;
476 : jhr 1116
477 : jhr 30 PrefixExpr
478 : jhr 2264 : SuffixExpr
479 :     => (SuffixExpr)
480 :     | "-" PrefixExpr
481 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_neg, PrefixExpr)))
482 :     | "!" PrefixExpr
483 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_not, PrefixExpr)))
484 :     ;
485 : jhr 25
486 : jhr 1116 SuffixExpr
487 : jhr 2264 : DerivExpr Suffix*
488 :     => (case Suffix
489 :     of [] => DerivExpr
490 :     | ss => markExpr(FULL_SPAN, List.foldl (fn (f, e) => f e) DerivExpr ss)
491 :     (* end case *))
492 :     ;
493 : jhr 39
494 : jhr 1116 Suffix
495 : jhr 2264 : "(" Arguments ")"
496 :     => (fn e => markExpr(FULL_SPAN, PT.E_Apply(e, Arguments)))
497 :     | "[" Indices "]"
498 :     => (fn e => PT.E_Slice(e, Indices))
499 :     | "." ID
500 :     => (fn e => PT.E_Selector(e, ID))
501 :     | "{" Expr "}"
502 :     => (fn e => PT.E_Subscript(e, Expr))
503 :     ;
504 : jhr 1116
505 : jhr 381 Indices
506 : jhr 2264 : Index ( "," Index )*
507 :     => (Index :: SR)
508 :     ;
509 : jhr 381
510 :     Index
511 : jhr 2264 : ":"
512 :     => (NONE)
513 :     | Expr
514 :     => (SOME Expr)
515 :     ;
516 : jhr 381
517 : jhr 1116 DerivExpr
518 : jhr 2264 : AtomExpr
519 :     => (AtomExpr)
520 :     | "∇" AtomExpr
521 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_D, AtomExpr)))
522 :     | "∇⊗" DerivExpr
523 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_Dotimes, DerivExpr)))
524 :     | "∇×" DerivExpr
525 : jhr 2298 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_curl, DerivExpr)))
526 : jhr 2264 | "∇•" DerivExpr
527 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_Ddot, DerivExpr)))
528 :     ;
529 : jhr 1116
530 : jhr 381 AtomExpr
531 : jhr 2264 : ID
532 :     => (markExpr(FULL_SPAN, PT.E_Var ID))
533 :     | "identity" "[" Dimension "]"
534 :     => (markExpr(FULL_SPAN, PT.E_Id Dimension))
535 :     | "zeros" Dimensions
536 :     => (markExpr(FULL_SPAN, PT.E_Zero Dimensions))
537 :     (* FIXME: factor these rules into the reduction and the comprehension *)
538 : lamonts 2265 | "maxr" "{" StrandSetVar "}"
539 : jhr 2264 => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Max, StrandSetVar)))
540 : lamonts 2265 | "minr" "{" StrandSetVar "}"
541 : jhr 2264 => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Min, StrandSetVar)))
542 :     | "sum" "{" StrandSetVar "}"
543 :     => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Sum, StrandSetVar)))
544 :     | "all" "{" StrandSetVar "}"
545 :     => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_All, StrandSetVar)))
546 :     | "exists" "{" StrandSetVar "}"
547 :     => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Exists, StrandSetVar)))
548 :     | "product" "{" StrandSetVar "}"
549 :     => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Product, StrandSetVar)))
550 :     | "mean" "{" StrandSetVar "}"
551 :     => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Mean, StrandSetVar)))
552 :     | "variance" "{" StrandSetVar "}"
553 :     => (markExpr(FULL_SPAN, PT.E_Reduction(PT.R_Variance, StrandSetVar)))
554 : jhr 1926 (* should the following be classified as SuffixExprs? *)
555 : jhr 2264 | "real" "(" Expr ")"
556 :     => (markExpr(FULL_SPAN, PT.E_Real Expr))
557 :     | LoadExpr
558 :     => (LoadExpr)
559 :     | "(" Expr ("," Expr)* ")"
560 :     => (case SR
561 :     of [] => Expr
562 :     | l => markExpr(FULL_SPAN, PT.E_Tuple(Expr::l))
563 :     (* end case *))
564 :     | "{" Expr ("," Expr)* "}"
565 :     => (markExpr(FULL_SPAN, PT.E_Sequence(Expr::SR)))
566 :     | "[" Expr ("," Expr)* "]"
567 :     => (markExpr(FULL_SPAN, PT.E_Cons(Expr::SR)))
568 :     | INT
569 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Int INT)))
570 :     | FLOAT
571 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Float FLOAT)))
572 :     | STRING
573 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.String STRING)))
574 :     | "true"
575 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Bool true)))
576 :     | "false"
577 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Bool false)))
578 :     | "|" Expr "|"
579 :     => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_norm, Expr)))
580 :     ;
581 : jhr 1301
582 :     (***** Initializers (constant expressions) *****)
583 :    
584 :     Initializer
585 : jhr 2264 : KW_identity "[" Dimension "]"
586 :     => (markExpr(FULL_SPAN, PT.E_Id Dimension))
587 :     | KW_zeros Dimensions
588 :     => (markExpr(FULL_SPAN, PT.E_Zero Dimensions))
589 :     | LoadExpr
590 :     => (LoadExpr)
591 :     | "{" Initializer ("," Initializer)* "}"
592 :     => (markExpr(FULL_SPAN, PT.E_Sequence(Initializer::SR)))
593 :     | "[" Initializer ("," Initializer)* "]"
594 :     => (markExpr(FULL_SPAN, PT.E_Cons(Initializer::SR)))
595 : jhr 1811 | "-" INT
596 : jhr 2264 => (markExpr(FULL_SPAN, PT.E_Lit(L.Int(~INT))))
597 : jhr 1811 | "-" FLOAT
598 : jhr 2264 => (markExpr(FULL_SPAN, PT.E_Lit(L.Float(FloatLit.negate FLOAT))))
599 :     | INT
600 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Int INT)))
601 :     | FLOAT
602 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Float FLOAT)))
603 :     | STRING
604 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.String STRING)))
605 :     | "true"
606 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Bool true)))
607 :     | "false"
608 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Bool false)))
609 :     ;
610 : jhr 1926
611 :     LoadExpr
612 : jhr 2264 : KW_image "(" STRING ")"
613 :     => (markExpr(FULL_SPAN, PT.E_Image STRING))
614 :     | KW_load "(" STRING ")"
615 :     => (markExpr(FULL_SPAN, PT.E_Load STRING))
616 :     ;

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