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

SCM Repository

[diderot] Annotation of /trunk/src/parser/diderot.grm
ViewVC logotype

Annotation of /trunk/src/parser/diderot.grm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 40 - (view) (download)

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

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