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

Parent Directory | Revision Log

---

Revision 82 - (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 :	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