Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/parser/diderot.grm
ViewVC logotype

Annotation of /branches/vis15/src/compiler/parser/diderot.grm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3482 - (view) (download)

1 : jhr 3352 (* diderot.grm
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2015 The University of Chicago
6 :     * All rights reserved.
7 :     *)
8 :    
9 :     %name Diderot;
10 :    
11 : jhr 3401 %start Root;
12 : jhr 3390
13 : jhr 3352 %tokens
14 :     : KW_bool ("bool")
15 : jhr 3390 | KW_collection ("collection")
16 :     | KW_const ("const")
17 : jhr 3352 | KW_continue ("continue")
18 :     | KW_die ("die")
19 :     | KW_else ("else")
20 :     | KW_false ("false")
21 :     | KW_field ("field")
22 :     | KW_foreach ("foreach")
23 :     | KW_function ("function")
24 : jhr 3390 | KW_global ("global") (* deprecated *)
25 :     | KW_grid ("grid")
26 :     | KW_identity ("identity")
27 : jhr 3352 | KW_if ("if")
28 :     | KW_image ("image")
29 :     | KW_in ("in")
30 :     | KW_initially ("initially")
31 : jhr 3390 | KW_input ("input")
32 : jhr 3352 | KW_int ("int")
33 :     | KW_kernel ("kernel")
34 :     | KW_load ("load")
35 : jhr 3390 | KW_mat2 ("mat2")
36 :     | KW_mat3 ("mat3")
37 :     | KW_mat4 ("mat4")
38 : jhr 3352 | KW_nan ("nan")
39 :     | KW_new ("new")
40 :     | KW_output ("output")
41 :     | KW_print ("print")
42 :     | KW_real ("real")
43 :     | KW_return ("return")
44 :     | KW_stabilize ("stabilize")
45 :     | KW_strand ("strand")
46 :     | KW_string ("string")
47 :     | KW_tensor ("tensor")
48 :     | KW_true ("true")
49 :     | KW_update ("update")
50 :     | KW_vec2 ("vec2")
51 :     | KW_vec3 ("vec3")
52 :     | KW_vec4 ("vec4")
53 : jhr 3390 | KW_zeros ("zeros")
54 : jhr 3352 | OP_eq ("=")
55 :     | OP_pluseq ("+=")
56 :     | OP_minuseq ("-=")
57 :     | OP_stareq ("*=")
58 :     | OP_slasheq ("/=")
59 :     | OP_modeq ("%=")
60 :     | OP_orelse ("||")
61 :     | OP_andalso ("&&")
62 :     | OP_lt ("<")
63 :     | OP_lte ("<=")
64 :     | OP_eqeq ("==")
65 :     | OP_neq ("!=")
66 :     | OP_gte (">=")
67 :     | OP_gt (">")
68 :     | OP_plus ("+")
69 :     | OP_minus ("-")
70 :     | OP_star ("*")
71 :     | OP_convolve ("⊛")
72 :     | OP_dot ("•")
73 :     | OP_cross ("×")
74 :     | OP_outer ("⊗")
75 :     | OP_slash ("/")
76 :     | OP_mod ("%")
77 :     | OP_exp ("^")
78 :     | OP_at ("@")
79 :     | OP_D ("∇")
80 :     | OP_Dotimes ("∇⊗")
81 :     | OP_curl ("∇×")
82 :     | OP_Ddot ("∇•")
83 :     | LP ("(")
84 :     | RP (")")
85 :     | LB ("[")
86 :     | RB ("]")
87 :     | LCB ("{")
88 :     | RCB ("}")
89 :     | COMMA (",")
90 :     | SEMI (";")
91 :     | COLON (":")
92 :     | HASH ("#")
93 :     | BANG ("!")
94 :     | BAR ("|")
95 :     | DOT (".")
96 :     | DOTDOT ("..")
97 : jhr 3390 | ID of Atom.atom
98 : jhr 3352 | INT of IntLit.t
99 :     | REAL of RealLit.t
100 :     | STRING of string
101 :     ;
102 :    
103 :     %keywords
104 :     KW_bool, KW_continue, KW_die, KW_else, KW_field, KW_foreach, KW_function, KW_identity,
105 :     KW_if, KW_image, KW_initially, KW_int, KW_kernel, KW_load, KW_new, KW_output, KW_print,
106 :     KW_real, KW_return, KW_stabilize, KW_strand, KW_string, KW_tensor, KW_update, KW_vec2,
107 :     KW_vec3, KW_vec4, KW_zeros;
108 :    
109 :     %defs (
110 :     structure PT = ParseTree
111 :     structure L = Literal
112 :     structure Op = Operators
113 :    
114 :     (* apply a mark constructor to a span and a tree *)
115 :     fun mark cons (span : AntlrStreamPos.span, tr) = cons{span = span, tree = tr}
116 :    
117 :     (* specialize mark functions for common node types *)
118 : jhr 3390 val markDecl = mark PT.GD_Mark
119 : jhr 3352 fun markTy (_, e as PT.T_Mark _) = e
120 :     | markTy (sp, tr) = mark PT.T_Mark (sp, tr)
121 :     fun markStmt (_, e as PT.S_Mark _) = e
122 :     | markStmt (sp, tr) = mark PT.S_Mark (sp, tr)
123 :     fun markExpr (_, e as PT.E_Mark _) = e
124 :     | markExpr (sp, tr) = mark PT.E_Mark (sp, tr)
125 :    
126 :     fun mkCondExp cons = let
127 : jhr 3390 fun mk (_, e, [], _) = e
128 :     | mk (lpos, e, [(_, e')], rpos) = markExpr((lpos, rpos), cons(e, e'))
129 :     | mk (lpos, e, (pos, e')::r, rpos) = markExpr((lpos, rpos), cons(e, mk(pos, e', r, rpos)))
130 : jhr 3352 in
131 :     mk
132 :     end
133 :    
134 :     (* build an application for an infix binary operator *)
135 :     fun mkBinApp (e1, rator, e2) = PT.E_BinOp(e1, rator, e2)
136 :    
137 :     (* construct application expressions for left-associative binary operators *)
138 : jhr 3390 fun mkLBinExp (_, e, []) = e
139 :     | mkLBinExp (lpos, e, (id, e', rpos)::r) =
140 :     mkLBinExp (lpos, markExpr((lpos, rpos), mkBinApp(e, id, e')), r)
141 : jhr 3352
142 :     (* construct application expressions for right-associative binary operators *)
143 : jhr 3390 fun mkRBinExp (_, e, [], _) = e
144 :     | mkRBinExp (lpos, e, [(id, _, e')], rpos) =
145 :     markExpr ((lpos, rpos), mkBinApp(e, id, e'))
146 :     | mkRBinExp (lpos, e, (id, pos, e')::r, rpos) =
147 :     markExpr ((lpos, rpos), mkBinApp(e, id, mkRBinExp(pos, e', r, rpos)))
148 : jhr 3352
149 :     fun mkOptExp (_, e, NONE) = e
150 :     | mkOptExp (spn, e, SOME mk) = mk(spn, e)
151 :    
152 :     fun flatten NONE = []
153 :     | flatten (SOME(x, xs)) = x::xs
154 :    
155 : jhr 3390 fun ilit i = PT.E_Lit(L.Int i)
156 : jhr 3352 );
157 :    
158 : jhr 3401 Root
159 :     : Program
160 :     => (PT.Program{span = FULL_SPAN, tree = Program})
161 :     ;
162 :    
163 : jhr 3390 Program
164 :     : ( GlobalDcl )* StrandDcl ProgramSuffix
165 :     => (let val ((init, create), update) = ProgramSuffix
166 :     in
167 : jhr 3401 {
168 : jhr 3390 globals = SR,
169 :     strand = StrandDcl,
170 :     init = init,
171 :     create = create,
172 :     update = update
173 :     }
174 :     end)
175 :     (*
176 :     : ( GlobalDcl )* StrandDcl Initialization ( GlobalUpdate )?
177 : jhr 3401 => ({
178 : jhr 3390 globals = SR1,
179 :     strand = StrandDcl,
180 :     init = fst Initialization,
181 :     create = snd Initialization,
182 :     update = SR2
183 :     })
184 :     *)
185 : jhr 3352 ;
186 :    
187 : jhr 3390 ProgramSuffix
188 :     : Initialization ( GlobalUpdate )?
189 :     => (Initialization, SR)
190 :     | OldGlobalUpdate "initially" (Array | Collection) ";"
191 :     => ((NONE, SR FULL_SPAN), SOME OldGlobalUpdate)
192 : jhr 3352 ;
193 :    
194 : jhr 3390 GlobalDcl
195 :     : InputDcl
196 :     => (InputDcl)
197 :     | ConstDcl
198 :     => (ConstDcl)
199 :     | VarDcl
200 :     => (markDecl(FULL_SPAN, PT.GD_Var VarDcl))
201 :     | FunctionDcl
202 :     => (FunctionDcl)
203 :     ;
204 : jhr 3352
205 : jhr 3390 ConstDcl
206 : jhr 3401 : "const" Type BindId ( "=" ConstExpr )? ";"
207 :     => (markDecl(FULL_SPAN, PT.GD_Const(Type, BindId, SR)))
208 : jhr 3352 ;
209 :    
210 : jhr 3390 InputDcl
211 : jhr 3401 : "input" Type BindId ( "(" STRING ")" )? ( "=" ConstExpr )? ";"
212 :     => (markDecl(FULL_SPAN, PT.GD_Input(Type, BindId, SR1, SR2)))
213 : jhr 3352 ;
214 :    
215 : jhr 3390 VarDcl
216 : jhr 3401 : Type BindId ( "=" Expression )? ";"
217 :     => (mark PT.VD_Mark (FULL_SPAN, PT.VD_Decl(Type, BindId, SR)))
218 : jhr 3352 ;
219 :    
220 : jhr 3390 FunctionDcl
221 : jhr 3401 : "function" Type BindId "(" Parameters ")" FunctionDef
222 :     => (markDecl(FULL_SPAN, PT.GD_Func(Type, BindId, Parameters, FunctionDef)))
223 : jhr 3352 ;
224 :    
225 : jhr 3390 Parameters
226 :     : ( Parameter ( "," Parameter )* )?
227 : jhr 3352 => (flatten SR)
228 :     ;
229 :    
230 : jhr 3390 Parameter
231 : jhr 3401 : Type BindId
232 :     => (mark PT.P_Mark (FULL_SPAN, PT.P_Param(Type, BindId)))
233 : jhr 3352 ;
234 :    
235 : jhr 3390 FunctionDef
236 :     : "=" Expression ";"
237 :     => (PT.FB_Expr Expression)
238 : jhr 3352 | Block
239 :     => (PT.FB_Stmt Block)
240 :     ;
241 :    
242 : jhr 3390 StrandDcl
243 : jhr 3401 : "strand" BindId "(" Parameters ")" "{" ( StateVarDcl )* ( MethodDcl )* "}"
244 : jhr 3390 => (mark PT.SD_Mark (FULL_SPAN, PT.SD_Strand{
245 : jhr 3401 name = BindId, params = Parameters, state = SR1, methods = SR2
246 : jhr 3352 }))
247 :     ;
248 :    
249 : jhr 3390 StateVarDcl
250 :     : "output" VarDcl
251 :     => (mark PT.SVD_Mark (FULL_SPAN, PT.SVD_VarDcl(true, VarDcl)))
252 :     | VarDcl
253 :     => (mark PT.SVD_Mark (FULL_SPAN, PT.SVD_VarDcl(false, VarDcl)))
254 : jhr 3352 ;
255 :    
256 : jhr 3390 MethodDcl
257 :     : MethodName Block
258 :     => (mark PT.M_Mark (FULL_SPAN, PT.M_Method(MethodName, Block)))
259 : jhr 3352 ;
260 :    
261 : jhr 3390 MethodName
262 : jhr 3401 : "initially" => (StrandUtil.Initially)
263 : jhr 3352 | "update" => (StrandUtil.Update)
264 :     | "stabilize" => (StrandUtil.Stabilize)
265 :     ;
266 :    
267 : jhr 3390 Initialization
268 :     : %try "initially" (Array | Collection) ";"
269 :     => (NONE, SR FULL_SPAN)
270 : jhr 3428 | %try ( "initially" Block )? InitialStrands
271 : jhr 3390 => (SR, InitialStrands)
272 : jhr 3352 ;
273 :    
274 : jhr 3390 InitialStrands
275 :     : "collection" Comprehension
276 :     => (mark PT.CR_Mark (FULL_SPAN, PT.CR_Collection Comprehension))
277 :     | "grid" "(" ConstExpr ")" Comprehension
278 :     => (mark PT.CR_Mark (FULL_SPAN, PT.CR_Grid(ConstExpr, Comprehension)))
279 : jhr 3352 ;
280 :    
281 : jhr 3390 Array
282 :     : "[" Create "|" Iterations "]"
283 :     => (fn span =>
284 :     mark PT.CR_Mark
285 :     (span, PT.CR_Deprecated(PT.CR_Grid(
286 :     ilit (IntLit.fromInt(List.length Iterations)),
287 :     mark PT.COMP_Mark
288 :     (FULL_SPAN, PT.COMP_Comprehension(Create, Iterations))))))
289 : jhr 3352 ;
290 :    
291 : jhr 3390 Collection
292 :     : "{" Create "|" Iterations "}"
293 :     => (fn span =>
294 :     mark PT.CR_Mark
295 :     (span, PT.CR_Deprecated(PT.CR_Collection(
296 :     mark PT.COMP_Mark
297 :     (FULL_SPAN, PT.COMP_Comprehension(Create, Iterations))))))
298 : jhr 3352 ;
299 :    
300 :     Create
301 :     : ID "(" Arguments ")"
302 : jhr 3390 => (markExpr (FULL_SPAN, PT.E_Apply(PT.E_Var ID, Arguments)))
303 : jhr 3352 ;
304 :    
305 :     Iterations
306 :     : Iteration ( "," Iteration )*
307 :     => (Iteration :: SR)
308 :     ;
309 :    
310 :     Iteration
311 : jhr 3401 : BindId "in" OrExpr ".." OrExpr
312 : jhr 3390 => (mark PT.I_Mark (
313 :     FULL_SPAN,
314 : jhr 3401 PT.I_Iterator(BindId,
315 : jhr 3390 markExpr((#1 OrExpr1_SPAN, #2 OrExpr2_SPAN),
316 :     PT.E_Range(OrExpr1, OrExpr2)))))
317 : jhr 3352 ;
318 :    
319 : jhr 3390 GlobalUpdate
320 :     : "update" Block
321 :     => (markStmt (FULL_SPAN, Block))
322 :     | OldGlobalUpdate
323 :     => (OldGlobalUpdate)
324 : jhr 3352 ;
325 :    
326 : jhr 3390 OldGlobalUpdate
327 :     : "global" Block
328 :     => (markStmt (FULL_SPAN,
329 :     PT.S_Deprecate(
330 :     "'global' keyword is deprecated; use 'update' instead",
331 :     Block)))
332 :     ;
333 : jhr 3352
334 : jhr 3390 Block
335 :     : "{" ( Statement )* "}"
336 :     => (case SR
337 :     of [s] => markStmt (FULL_SPAN, s)
338 :     | stms => markStmt (FULL_SPAN, PT.S_Block stms)
339 :     (* end case *))
340 :     ;
341 : jhr 3352
342 : jhr 3390 Statement
343 :     : AtomicStmt
344 :     | "if" "(" Expression ")" Statement IfRest
345 :     => (IfRest (FULL_SPAN, Expression, Statement))
346 : jhr 3428 | "foreach" "(" Type Iterator ")" Statement
347 :     => (markStmt (FULL_SPAN, PT.S_Foreach(Type, Iterator, Statement)))
348 : jhr 3390 ;
349 :    
350 :     IfRest
351 :     : (* empty *)
352 :     => (fn (span, e, s) => markStmt (span, PT.S_IfThen(e, s)))
353 :     | "else" Statement
354 :     => (fn (span, e, s) => markStmt (span, PT.S_IfThenElse(e, s, Statement)))
355 :     ;
356 :    
357 :     AtomicStmt
358 :     : Block
359 :     => (Block)
360 :     | "print" "(" Arguments ")" ";"
361 :     => (markStmt (FULL_SPAN, PT.S_Print Arguments))
362 :     | "new" ID "(" Arguments ")" ";"
363 :     => (markStmt (FULL_SPAN, PT.S_New(ID, Arguments)))
364 :     | "stabilize" ";"
365 :     => (markStmt (FULL_SPAN, PT.S_Stabilize))
366 :     | "die" ";"
367 :     => (markStmt (FULL_SPAN, PT.S_Die))
368 :     | "continue" ";"
369 :     => (markStmt (FULL_SPAN, PT.S_Continue))
370 :     | "return" Expression ";"
371 :     => (markStmt (FULL_SPAN, PT.S_Return Expression))
372 :     | VarDcl
373 :     => (PT.S_Decl VarDcl)
374 : jhr 3408 | BindId "=" Expression ";"
375 :     => (markStmt (FULL_SPAN, PT.S_Assign(BindId, NONE, Expression)))
376 :     | BindId AssignOp Expression ";"
377 :     => (markStmt (FULL_SPAN, PT.S_Assign(BindId, SOME AssignOp, Expression)))
378 : jhr 3390 ;
379 :    
380 :     AssignOp
381 :     : "+=" => (Op.asgn_add)
382 :     | "-=" => (Op.asgn_sub)
383 :     | "*=" => (Op.asgn_mul)
384 :     | "/=" => (Op.asgn_div)
385 :     | "%=" => (Op.asgn_mod)
386 :     ;
387 :    
388 :     Type
389 :     : "image" "(" ConstExpr ")" Shape
390 :     => (markTy (FULL_SPAN, PT.T_Image{dim=ConstExpr, shape=Shape}))
391 :     | "field" "#" Dimension "(" ConstExpr ")" Shape
392 :     => (markTy (FULL_SPAN, PT.T_Field{diff=Dimension, dim=ConstExpr, shape=Shape}))
393 : jhr 3352 | "kernel" "#" Dimension
394 : jhr 3390 => (markTy (FULL_SPAN, PT.T_Kernel Dimension))
395 : jhr 3352 | ConcreteType
396 : jhr 3390 => (ConcreteType)
397 : jhr 3352 ;
398 :    
399 : jhr 3390 Dimension
400 :     : INT => (INT)
401 :     ;
402 :    
403 : jhr 3352 ConcreteType
404 : jhr 3390 : PrimitiveType SequenceDims
405 :     => (markTy (FULL_SPAN, SequenceDims PrimitiveType))
406 : jhr 3352 ;
407 :    
408 : jhr 3390 SequenceDims
409 : jhr 3352 : (* empty *)
410 :     => (fn ty => ty)
411 : jhr 3390 | "[" "]"
412 : jhr 3352 => (fn ty => PT.T_DynSeq ty)
413 : jhr 3390 | "[" ConstExpr "]" SequenceDims
414 :     => (fn ty => SequenceDims(PT.T_Seq(ty, ConstExpr)))
415 : jhr 3426 | "{" "}"
416 :     => (fn ty => PT.T_Deprecate(
417 :     "'{}' is deprecated for sequence types, please use '[]' instead",
418 :     PT.T_DynSeq ty))
419 :     | "{" ConstExpr "}" SequenceDims
420 :     => (fn ty => PT.T_Deprecate(
421 :     "'{}' is deprecated for sequence types, please use '[]' instead",
422 :     SequenceDims(PT.T_Seq(ty, ConstExpr))))
423 : jhr 3352 ;
424 :    
425 : jhr 3390 PrimitiveType
426 :     : "tensor" Shape => (markTy(FULL_SPAN, PT.T_Tensor Shape))
427 :     | "vec2" => (PT.T_Tensor[ilit 2])
428 :     | "vec3" => (PT.T_Tensor[ilit 3])
429 :     | "vec4" => (PT.T_Tensor[ilit 4])
430 :     | "mat2" => (PT.T_Tensor[ilit 2, ilit 2])
431 :     | "mat3" => (PT.T_Tensor[ilit 3, ilit 3])
432 :     | "mat4" => (PT.T_Tensor[ilit 4, ilit 4])
433 :     | "bool" => (PT.T_Bool)
434 :     | "int" => (PT.T_Int)
435 :     | "real" => (PT.T_Tensor[])
436 :     | "string" => (PT.T_String)
437 : jhr 3428 | ID => (PT.T_Id ID)
438 : jhr 3352 ;
439 :    
440 : jhr 3390 Shape
441 :     : "[" ( ConstExpr ( "," ConstExpr )* )? "]"
442 :     => (flatten (SR : (PT.expr * PT.expr list) option))
443 : jhr 3352 ;
444 :    
445 : jhr 3390 Comprehension
446 :     : "{" Expression "|" Iterator ( "," Iterator )* "}"
447 :     => (mark PT.COMP_Mark
448 :     (FULL_SPAN, PT.COMP_Comprehension(Expression, Iterator :: SR)))
449 : jhr 3352 ;
450 :    
451 : jhr 3390 Iterator
452 : jhr 3401 : BindId "in" Expression
453 :     => (mark PT.I_Mark (FULL_SPAN, PT.I_Iterator(BindId, Expression)))
454 : jhr 3352 ;
455 :    
456 : jhr 3390 Expression
457 :     : RangeExpr ( "if" Expression "else" Expression => (Expression1, Expression2) )?
458 :     => (case SR
459 :     of NONE => RangeExpr
460 :     | SOME(e1, e2) => markExpr(FULL_SPAN, PT.E_Cond(RangeExpr, e1, e2))
461 :     (* end case *))
462 :     ;
463 : jhr 3352
464 : jhr 3390 RangeExpr
465 :     : OrExpr ( ".." OrExpr )?
466 : jhr 3352 => (case SR
467 : jhr 3390 of NONE => OrExpr
468 :     | SOME e => markExpr (FULL_SPAN, PT.E_Range(OrExpr, e))
469 : jhr 3352 (* end case *))
470 :     ;
471 :    
472 : jhr 3390 OrExpr
473 :     : AndExpr ( "||" AndExpr => (#1 FULL_SPAN, AndExpr) )*
474 :     => (mkCondExp PT.E_OrElse (#1 AndExpr_SPAN, AndExpr, SR, #2 SR_SPAN))
475 : jhr 3352 ;
476 :    
477 :     AndExpr
478 : jhr 3390 : CompareExpr ( "&&" CompareExpr => (#1 FULL_SPAN, CompareExpr) )*
479 :     => (mkCondExp PT.E_AndAlso (#1 CompareExpr_SPAN, CompareExpr, SR, #2 SR_SPAN))
480 : jhr 3352 ;
481 :    
482 : jhr 3390 CompareExpr
483 :     : AddExpr ( CompareOp AddExpr => (CompareOp, AddExpr, #2 AddExpr_SPAN) )*
484 :     => (mkLBinExp (#1 AddExpr_SPAN, AddExpr, SR))
485 : jhr 3352 ;
486 :    
487 : jhr 3390 CompareOp
488 :     : "<" => (Op.op_lt)
489 :     | "<=" => (Op.op_lte)
490 :     | "==" => (Op.op_equ)
491 :     | "!=" => (Op.op_neq)
492 :     | ">=" => (Op.op_gte)
493 :     | ">" => (Op.op_gt)
494 : jhr 3352 ;
495 :    
496 :     AddExpr
497 : jhr 3390 : MultiplyExpr ( AddOp MultiplyExpr => (AddOp, MultiplyExpr, #2 MultiplyExpr_SPAN) )*
498 :     => (mkLBinExp (#1 MultiplyExpr_SPAN, MultiplyExpr, SR))
499 : jhr 3352 ;
500 :    
501 :     AddOp
502 : jhr 3390 : "+" => (Op.op_add)
503 :     | "-" => (Op.op_sub)
504 :     | "@" => (Op.op_at)
505 : jhr 3352 ;
506 :    
507 : jhr 3390 MultiplyExpr
508 :     : PrefixExpr ( MultiplyOp PrefixExpr => (MultiplyOp, PrefixExpr, #2 PrefixExpr_SPAN) )*
509 :     => (mkLBinExp (#1 PrefixExpr_SPAN, PrefixExpr, SR))
510 : jhr 3352 ;
511 :    
512 : jhr 3390 MultiplyOp
513 :     : "*" => (Op.op_mul)
514 :     | "/" => (Op.op_div)
515 :     | "%" => (Op.op_mod)
516 :     | "⊛" => (Op.op_convolve)
517 :     | "•" => (Op.op_dot)
518 :     | "×" => (Op.op_cross)
519 :     | "⊗" => (Op.op_outer)
520 :     | ":" => (Op.op_colon)
521 : jhr 3352 ;
522 :    
523 :     PrefixExpr
524 :     : PowerExpr
525 :     => (PowerExpr)
526 : jhr 3390 | PrefixOp PrefixExpr
527 :     => (markExpr (FULL_SPAN, PT.E_UnaryOp(PrefixOp, PrefixExpr)))
528 : jhr 3352 ;
529 :    
530 : jhr 3390 PrefixOp
531 :     : "-" => (Op.op_neg)
532 :     | "!" => (Op.op_not)
533 :     ;
534 :    
535 : jhr 3352 PowerExpr
536 : jhr 3482 : SuffixExpr ( "^" SuffixExpr => (Op.op_pow, #1 SuffixExpr_SPAN, SuffixExpr) )*
537 : jhr 3390 => (mkRBinExp (#1 FULL_SPAN, SuffixExpr, SR, #2 FULL_SPAN))
538 : jhr 3352 ;
539 :    
540 :     SuffixExpr
541 : jhr 3426 : %try DiffExpr "{" Expression CompRest
542 :     => (markExpr (FULL_SPAN, CompRest (DiffExpr, Expression)))
543 :     | %try DiffExpr ( Suffix )*
544 : jhr 3390 => (case SR
545 :     of [] => DiffExpr
546 :     | ss => markExpr(FULL_SPAN, List.foldl (fn (f, e) => f e) DiffExpr ss)
547 : jhr 3352 (* end case *))
548 : jhr 3426 (*
549 :     | ID "{" Expression "|" Iterator "}"
550 :     => (markExpr (FULL_SPAN,
551 :     PT.E_Apply(PT.E_Var ID,
552 :     [PT.E_SeqComp(PT.COMP_Comprehension(Expression, [Iterator]))])))
553 :     *)
554 : jhr 3390 | "real" "(" Expression ")"
555 :     => (markExpr (FULL_SPAN, PT.E_Real Expression))
556 :     | "load" "(" ConstExpr ")"
557 :     => (markExpr (FULL_SPAN, PT.E_Load ConstExpr))
558 :     | "image" "(" ConstExpr ")"
559 :     => (markExpr (FULL_SPAN, PT.E_Image ConstExpr))
560 :     | "identity" "[" ConstExpr "]"
561 :     => (markExpr (FULL_SPAN, PT.E_Id ConstExpr))
562 :     | "zeros" Shape
563 :     => (markExpr (FULL_SPAN, PT.E_Zero Shape))
564 :     | "nan" ( Shape )?
565 :     => (markExpr (FULL_SPAN, PT.E_NaN(getOpt(SR, []))))
566 : jhr 3352 ;
567 :    
568 : jhr 3426 CompRest
569 :     : "|" Iterator "}"
570 :     => (fn (e0, e1) =>
571 :     PT.E_Apply(e0,
572 :     [PT.E_SeqComp(PT.COMP_Comprehension(e1, [Iterator]))]))
573 :     | "}" (* old-style subscripting *)
574 :     => (fn (e0, e1) =>
575 :     PT.E_Deprecate(
576 :     "'{}' is deprecated for sequence indexing, please use '[]' instead",
577 :     PT.E_Subscript(e0, [SOME e1])))
578 :     ;
579 :    
580 : jhr 3352 Suffix
581 :     : "(" Arguments ")"
582 : jhr 3390 => (fn e => PT.E_Apply(e, Arguments))
583 : jhr 3352 | "[" Indices "]"
584 : jhr 3390 => (fn e => PT.E_Subscript(e, Indices))
585 :     | "." ID
586 : jhr 3352 => (fn e => PT.E_Select(e, ID))
587 :     ;
588 :    
589 :     Indices
590 : jhr 3390 : IndexExpr ( "," IndexExpr )*
591 :     => (IndexExpr :: SR)
592 : jhr 3352 ;
593 :    
594 : jhr 3390 IndexExpr
595 :     : Expression
596 :     => (SOME Expression)
597 :     | ":"
598 : jhr 3352 => (NONE)
599 :     ;
600 :    
601 : jhr 3390 DiffExpr
602 :     : AtomicExpr
603 :     => (AtomicExpr)
604 :     | DiffOp DiffExpr
605 :     => (markExpr (FULL_SPAN, PT.E_UnaryOp(DiffOp, DiffExpr)))
606 : jhr 3352 ;
607 :    
608 : jhr 3390 DiffOp
609 :     : "∇" => (Op.op_D)
610 :     | "∇⊗" => (Op.op_Dotimes)
611 :     | "∇×" => (Op.op_curl)
612 :     | "∇•" => (Op.op_Ddot)
613 :     ;
614 :    
615 :     AtomicExpr
616 : jhr 3352 : ID
617 : jhr 3390 => (markExpr (FULL_SPAN, PT.E_Var ID))
618 :     | ID "#" Dimension
619 :     => (markExpr (FULL_SPAN, PT.E_Kernel(ID, Dimension)))
620 : jhr 3352 | INT
621 : jhr 3390 => (markExpr (FULL_SPAN, ilit INT))
622 : jhr 3352 | REAL
623 : jhr 3390 => (markExpr (FULL_SPAN, PT.E_Lit(L.Real REAL)))
624 : jhr 3352 | STRING
625 : jhr 3390 => (markExpr (FULL_SPAN, PT.E_Lit(L.String STRING)))
626 : jhr 3352 | "true"
627 : jhr 3390 => (markExpr (FULL_SPAN, PT.E_Lit(L.Bool true)))
628 : jhr 3352 | "false"
629 : jhr 3390 => (markExpr (FULL_SPAN, PT.E_Lit(L.Bool false)))
630 :     | "(" Expression ")"
631 :     => (Expression)
632 :     | "{" "}"
633 :     => (markExpr (FULL_SPAN, PT.E_Sequence[]))
634 :     | "{" Expression SeqRest "}"
635 :     => (markExpr (FULL_SPAN, SeqRest Expression))
636 :     | "[" Expression ( "," Expression )* "]"
637 :     => (markExpr (FULL_SPAN, PT.E_Cons(Expression::SR)))
638 :     | "|" Expression "|"
639 : jhr 3401 => (markExpr (FULL_SPAN, PT.E_UnaryOp(BasisNames.op_norm, Expression)))
640 : jhr 3352 ;
641 :    
642 : jhr 3390 Arguments
643 :     : (* empty *)
644 :     => ([])
645 :     | Expression ( "," Expression )*
646 :     => (Expression :: SR)
647 : jhr 3352 ;
648 :    
649 : jhr 3390 SeqRest
650 :     : ( "," Expression )*
651 :     => (fn e => PT.E_Sequence(e::SR))
652 :     | "|" Iterator
653 :     => (fn e => PT.E_SeqComp(PT.COMP_Comprehension(e, [Iterator])))
654 : jhr 3352 ;
655 :    
656 :     ConstExpr
657 : jhr 3390 : Expression
658 :     => (Expression)
659 : jhr 3352 ;
660 : jhr 3401
661 :     (* binding occurrence of an identifier *)
662 :     BindId
663 :     : ID
664 :     => ({span=ID_SPAN, tree=ID})
665 : jhr 3426 ;

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