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 82 - (view) (download)
Original Path: trunk/src/parser/diderot.grm

1 : jhr 14 (* diderot.grm
2 :     *
3 :     * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 :     %name Diderot;
8 :    
9 :     %tokens
10 :     : KW_actor ("actor")
11 : jhr 25 | KW_bool ("bool")
12 : jhr 39 | KW_D ("D")
13 : jhr 19 | KW_die ("die")
14 : jhr 25 | KW_else ("else")
15 : jhr 14 | KW_field ("field")
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 19 | KW_new ("new")
24 : jhr 25 | KW_real ("real")
25 :     | KW_stabilize ("stabilize")
26 :     | KW_string ("string")
27 :     | KW_tensor ("tensor")
28 : jhr 48 | KW_vec2 ("vec2")
29 :     | KW_vec3 ("vec3")
30 :     | KW_vec4 ("vec4")
31 : jhr 25 | OP_eq ("=")
32 : jhr 19 | OP_orelse ("||")
33 :     | OP_andalso ("&&")
34 :     | OP_lt ("<")
35 :     | OP_lte ("<=")
36 :     | OP_eqeq ("==")
37 :     | OP_neq ("!=")
38 :     | OP_gte (">=")
39 :     | OP_gt (">")
40 : jhr 14 | OP_plus ("+")
41 :     | OP_minus ("-")
42 :     | OP_star ("*")
43 : jhr 19 | OP_slash ("/")
44 : jhr 14 | OP_at ("@")
45 :     | LP ("(")
46 :     | RP (")")
47 :     | LB ("[")
48 :     | RB ("]")
49 :     | LCB ("{")
50 :     | RCB ("}")
51 : jhr 25 | COMMA (",")
52 : jhr 30 | SEMI (";")
53 : jhr 25 | HASH ("#")
54 : jhr 26 | BANG ("!")
55 : jhr 40 | BAR ("|")
56 :     | DOTDOT ("..")
57 :     | INT of IntInf.int
58 : jhr 14 | FLOAT of FloatLit.float
59 :     | STRING of string
60 : jhr 19 | ID of Atom.atom
61 : jhr 14 ;
62 :    
63 : jhr 25 %defs (
64 : jhr 27 structure PT = ParseTree
65 :     structure L = Literal
66 : jhr 78 structure B = BasisNames
67 : jhr 27
68 : jhr 25 (* apply a mark constructor to a span and a tree *)
69 :     fun mark cons (span : AntlrStreamPos.span, tr) = cons{span = span, tree = tr}
70 :    
71 : jhr 27 (* specialize mark functions for common node types *)
72 :     val markDecl = mark PT.D_Mark
73 :     fun markTy (_, e as PT.T_Mark _) = e
74 :     | markTy (sp, tr) = mark PT.T_Mark (sp, tr)
75 :     fun markStmt (_, e as PT.S_Mark _) = e
76 :     | markStmt (sp, tr) = mark PT.S_Mark (sp, tr)
77 : jhr 30 fun markExpr (_, e as PT.E_Mark _) = e
78 :     | markExpr (sp, tr) = mark PT.E_Mark (sp, tr)
79 : jhr 27
80 : jhr 79 fun mkCondExp cons = let
81 :     fun mk (e, []) = e
82 :     | mk (e, [e']) = cons(e, e')
83 :     | mk (e, e'::r) = cons(e, mk(e', r))
84 :     in
85 :     mk
86 :     end
87 : jhr 78
88 : jhr 28 (* build an application for an infix binary operator *)
89 :     fun mkBinApp (e1, rator, e2) = PT.E_BinOp(e1, rator, e2)
90 :    
91 :     (* construct application expressions for left-associative binary operators *)
92 :     fun mkLBinExp (e, []) = e
93 :     | mkLBinExp (e, (id, e')::r) = mkLBinExp (mkBinApp(e, id, e'), r)
94 :    
95 :     (* construct application expressions for right-associative binary operators *)
96 :     fun mkRBinExp (e, []) = e
97 :     | mkRBinExp (e, [(id, e')]) = mkBinApp(e, id, e')
98 :     | mkRBinExp (e, (id, e')::r) = mkBinApp(e, id, mkRBinExp(e', r))
99 :    
100 : jhr 27 fun flatten NONE = []
101 : jhr 30 | flatten (SOME(x, xs)) = x::xs
102 :    
103 : jhr 25 );
104 :    
105 : jhr 14 File
106 : jhr 81 : Decl+ => (PT.Program{span=FULL_SPAN, tree=Decl})
107 : jhr 14 ;
108 :    
109 :     Decl
110 : jhr 23 : InputDecl
111 : jhr 30 | VarDecl => (PT.D_Var VarDecl)
112 : jhr 14 | ActorDecl
113 : jhr 40 | CoordinationDecl
114 : jhr 14 ;
115 :    
116 : jhr 23
117 :     (***** Inputs *****)
118 :    
119 :     InputDecl
120 :     : "input" Type ID ( "=" Expr )? ";"
121 : jhr 27 => (markDecl(FULL_SPAN, PT.D_Input(Type, ID, SR)))
122 : jhr 14 ;
123 : jhr 19
124 : jhr 27 (***** variable declarations *****)
125 : jhr 19
126 : jhr 27 VarDecl
127 : jhr 23 : Type ID "=" Expr ";"
128 : jhr 27 => (mark PT.VD_Mark (FULL_SPAN, PT.VD_Decl(Type, ID, Expr)))
129 : jhr 23 ;
130 :    
131 :    
132 : jhr 19 (***** Actors *****)
133 :    
134 :     ActorDecl
135 : jhr 27 : "actor" ID "(" Params ")" "{" VarDecl* ActorMethod+ "}"
136 :     => (markDecl(FULL_SPAN, PT.D_Actor{
137 :     name = ID, params = Params, state = VarDecl,
138 :     methods = ActorMethod
139 :     }))
140 : jhr 19 ;
141 :    
142 :     Params
143 :     : ( Param ( "," Param )* )?
144 : jhr 27 => (flatten SR)
145 : jhr 19 ;
146 :    
147 :     Param
148 :     : Type ID
149 : jhr 27 => (mark PT.P_Mark (FULL_SPAN, PT.P_Param(Type, ID)))
150 : jhr 19 ;
151 :    
152 :     ActorMethod
153 : jhr 24 : ID Block
154 : jhr 30 => (mark PT.M_Mark (FULL_SPAN, PT.M_Method(ID, Block)))
155 : jhr 19 ;
156 :    
157 : jhr 24 Block
158 : jhr 25 : "{" Stmt* "}"
159 :     => (markStmt(FULL_SPAN, PT.S_Block Stmt))
160 : jhr 24 ;
161 : jhr 19
162 : jhr 25 Stmt
163 :     : AtomicStmt
164 :     => (AtomicStmt)
165 :     | %try "if" "(" Expr ")" Stmt "else" Stmt
166 :     => (markStmt(FULL_SPAN, PT.S_IfThenElse(Expr, Stmt1, Stmt2)))
167 :     | %try "if" "(" Expr ")" Stmt
168 :     => (markStmt(FULL_SPAN, PT.S_IfThen(Expr, Stmt)))
169 :     ;
170 :    
171 :     AtomicStmt
172 :     : Block
173 :     => (Block)
174 : jhr 27 | VarDecl
175 :     => (PT.S_Decl VarDecl)
176 : jhr 25 | "stabilize" ";"
177 :     => (markStmt(FULL_SPAN, PT.S_Stabilize))
178 :     | "die" ";"
179 :     => (markStmt(FULL_SPAN, PT.S_Die))
180 :     | "new" ID "(" Arguments ")" ";"
181 :     => (markStmt(FULL_SPAN, PT.S_New(ID, Arguments)))
182 : jhr 24 | ID "=" Expr ";"
183 : jhr 25 => (markStmt(FULL_SPAN, PT.S_Assign(ID, Expr)))
184 : jhr 24 ;
185 :    
186 :     Arguments
187 :     : ( Expr ("," Expr)* )?
188 : jhr 27 => (flatten SR)
189 : jhr 24 ;
190 :    
191 :    
192 : jhr 40 (***** Coordination declaration *****)
193 :    
194 :     CoordinationDecl
195 :     : "initially" (Array | Collection) ";"
196 :     => (markDecl(FULL_SPAN, SR))
197 :     ;
198 :    
199 :     Array
200 :     : "[" Create "|" Iterations "]"
201 :     => (PT.D_InitialArray(Create, Iterations))
202 :     ;
203 :    
204 :     Create
205 :     : ID "(" Arguments ")"
206 :     => (mark PT.C_Mark (FULL_SPAN, PT.C_Create(ID, Arguments)))
207 :     ;
208 :    
209 :     Iterations
210 :     : Iteration ( "," Iteration )+
211 :     => (Iteration :: SR)
212 :     ;
213 :    
214 :     Iteration
215 :     : ID "in" Expr ".." Expr
216 :     => (mark PT.I_Mark (FULL_SPAN, PT.I_Range(ID, Expr1, Expr2)))
217 :     ;
218 :    
219 :     Collection
220 :     : "{" Create "|" Iterations "]"
221 :     => (PT.D_InitialCollection(Create, Iterations))
222 :     ;
223 :    
224 : jhr 19 (***** Types *****)
225 :    
226 : jhr 48 Type : "image" "(" Dimension ")" Dimensions
227 : jhr 39 => (markTy(FULL_SPAN, PT.T_Image{
228 : jhr 70 shape = Dimensions, dim = Dimension
229 : jhr 39 }))
230 : jhr 48 | "field" "#" Dimension "(" Dimension ")" Dimensions
231 : jhr 39 => (markTy(FULL_SPAN, PT.T_Field{
232 :     diff = Dimension1,
233 : jhr 70 shape = Dimensions,
234 : jhr 39 dim = Dimension2
235 :     }))
236 : jhr 23 | "kernel" "#" Dimension
237 : jhr 26 => (markTy(FULL_SPAN, PT.T_Kernel Dimension))
238 : jhr 39 | ValueType ("[" Dimension "]")*
239 :     => (case SR
240 :     of [] => ValueType
241 :     | d => (markTy(FULL_SPAN, PT.T_Array(ValueType, d)))
242 :     (* end case *))
243 : jhr 37 ;
244 :    
245 :     ValueType
246 : jhr 39 : "tensor" Dimensions
247 : jhr 37 => (markTy(FULL_SPAN, PT.T_Tensor Dimensions))
248 : jhr 48 | "vec2"
249 :     => (markTy(FULL_SPAN, PT.T_Vec 2))
250 :     | "vec3"
251 :     => (markTy(FULL_SPAN, PT.T_Vec 3))
252 :     | "vec4"
253 :     => (markTy(FULL_SPAN, PT.T_Vec 4))
254 : jhr 23 | "bool"
255 : jhr 26 => (markTy(FULL_SPAN, PT.T_Bool))
256 : jhr 19 | "int"
257 : jhr 26 => (markTy(FULL_SPAN, PT.T_Int))
258 : jhr 19 | "real"
259 : jhr 26 => (markTy(FULL_SPAN, PT.T_Real))
260 : jhr 24 | "string"
261 : jhr 26 => (markTy(FULL_SPAN, PT.T_String))
262 : jhr 19 ;
263 :    
264 : jhr 24 Dimensions
265 : jhr 48 : "[" ( Dimension ("," Dimension)* )? "]"
266 : jhr 27 => (flatten SR)
267 : jhr 24 ;
268 :    
269 : jhr 23 Dimension
270 : jhr 40 : INT
271 :     => (INT)
272 : jhr 23 ;
273 : jhr 19
274 :     (***** Expressions *****)
275 :    
276 :     Expr
277 : jhr 79 : AndExpr ( "||" AndExpr )*
278 :     => (mkCondExp PT.E_OrElse (AndExpr, SR))
279 : jhr 19 ;
280 :    
281 : jhr 30 AndExpr
282 : jhr 79 : CmpExpr ( "&&" CmpExpr )*
283 :     => (mkCondExp PT.E_AndAlso (CmpExpr, SR))
284 : jhr 19 ;
285 :    
286 : jhr 30 CmpExpr
287 :     : AddExpr ( CmpOp AddExpr )*
288 :     => (mkLBinExp (AddExpr, SR))
289 : jhr 19 ;
290 :    
291 : jhr 25 CmpOp
292 : jhr 79 : "<" => (B.op_lt) | "<=" => (B.op_lte)
293 :     | "==" => (B.op_equ) | "!=" => (B.op_neq)
294 :     | ">=" => (B.op_gte) | ">" => (B.op_gt)
295 : jhr 19 ;
296 :    
297 : jhr 30 AddExpr
298 :     : MulExpr ( AddOp MulExpr )*
299 :     => (mkLBinExp (MulExpr, SR))
300 : jhr 19 ;
301 :    
302 :     AddOp
303 : jhr 79 : "+" => (B.op_add) | "-" => (B.op_sub)
304 : jhr 19 ;
305 :    
306 : jhr 30 MulExpr
307 : jhr 39 : PrefixExpr ( MulOp PrefixExpr )*
308 :     => (mkLBinExp (PrefixExpr, SR))
309 : jhr 19 ;
310 :    
311 :     MulOp
312 : jhr 79 : "*" => (B.op_mul) | "/" => (B.op_div)
313 : jhr 19 ;
314 :    
315 : jhr 30 PrefixExpr
316 : jhr 39 : SelExpr
317 :     => (SelExpr)
318 : jhr 30 | "-" PrefixExpr
319 : jhr 79 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_neg, PrefixExpr)))
320 : jhr 30 | "!" PrefixExpr
321 : jhr 79 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_not, PrefixExpr)))
322 : jhr 39 | "D" PrefixExpr
323 : jhr 79 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_D, PrefixExpr)))
324 : jhr 25 ;
325 :    
326 : jhr 39 SelExpr
327 : jhr 79 : AtomExp ( "@" AtomExp => (B.op_at, AtomExp) | "[" Expr "]" => (B.op_subscript, Expr) )*
328 : jhr 39 => (mkRBinExp (AtomExp, SR))
329 :     ;
330 :    
331 : jhr 19 AtomExp
332 : jhr 35 : ID ( "(" Arguments ")" )?
333 :     => (case SR
334 :     of NONE => markExpr(FULL_SPAN, PT.E_Var ID)
335 :     | SOME args => markExpr(FULL_SPAN, PT.E_Apply(ID, args))
336 :     (* end case *))
337 : jhr 37 | ValueType "(" Arguments ")"
338 :     => (markExpr(FULL_SPAN, PT.E_Cons(ValueType, Arguments)))
339 : jhr 40 | INT
340 :     => (markExpr(FULL_SPAN, PT.E_Lit(L.Int INT)))
341 : jhr 19 | FLOAT
342 : jhr 30 => (markExpr(FULL_SPAN, PT.E_Lit(L.Float FLOAT)))
343 : jhr 19 | STRING
344 : jhr 27 => (markExpr(FULL_SPAN, PT.E_Lit(L.String STRING)))
345 : jhr 19 | "(" Expr ("," Expr)* ")"
346 : jhr 27 => (case SR
347 :     of [] => Expr
348 :     | l => markExpr(FULL_SPAN, PT.E_Tuple(Expr::l))
349 :     (* end case *))
350 : jhr 45 | "|" Expr "|"
351 : jhr 82 => (markExpr(FULL_SPAN, PT.E_UnaryOp(B.op_norm, Expr)))
352 : jhr 19 ;

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