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

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

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