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

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