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

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