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 1926 - (view) (download)
Original Path: branches/vis12/src/compiler/parser/diderot.grm

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

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