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

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