Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/branches/idlbasis-devel/src/MLRISC/Tools/Parser/mdl.grm
ViewVC logotype

Annotation of /sml/branches/idlbasis-devel/src/MLRISC/Tools/Parser/mdl.grm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 744 - (view) (download)
Original Path: sml/trunk/src/MLRISC/Tools/Parser/mdl.grm

1 : leunga 744 (* There are 30 shift/reduce errors *)
2 :    
3 :     structure Ast = AstPP.Ast
4 :     structure Prec = PrecedenceParser
5 :     open Ast
6 :    
7 :     val precStacks= ref [] : PrecedenceParser.precedence_stack list ref
8 :     fun newScope precStack = precStacks := !precStack :: !precStacks
9 :     fun oldScope precStack =
10 :     case !precStacks of
11 :     h::t => (precStacks := t; precStack := h)
12 :    
13 :     fun Infix precStack (p,[]) = ()
14 :     | Infix precStack (p,id::ids) =
15 :     (precStack := Prec.declare(!precStack,id,Prec.INFIX p);
16 :     Infix precStack (p,ids))
17 :    
18 :     fun Infixr precStack (p,[]) = ()
19 :     | Infixr precStack (p,id::ids) =
20 :     (precStack := Prec.declare(!precStack,id,Prec.INFIXR p);
21 :     Infixr precStack (p,ids))
22 :    
23 :     fun Nonfix precStack ([]) = ()
24 :     | Nonfix precStack (id::ids) =
25 :     (precStack := Prec.declare(!precStack,id,Prec.NONFIX);
26 :     Nonfix precStack (ids))
27 :    
28 :     fun p2s p = PP.text(AstPP.pat p)
29 :     fun e2s e = PP.text(AstPP.exp e)
30 :     fun ps2s ps = PP.text(PP.concat(map AstPP.pat ps))
31 :    
32 :     fun precErr err loc msg = err(loc,msg)
33 :    
34 :     fun STRINGexp s = LITexp(STRINGlit s)
35 :     fun BOOLexp b = LITexp(BOOLlit b)
36 :    
37 :     fun parseExp precStack err loc toks =
38 :     Prec.parse{error=precErr err loc,app=APPexp,tuple=TUPLEexp,
39 :     id=fn id => IDexp(IDENT([],id)),stack= !precStack,
40 :     toString=e2s, kind="expression"} toks
41 :    
42 :     fun parsePat precStack err loc toks =
43 :     let fun appPat (IDpat id,p) = CONSpat(IDENT([],id),SOME p)
44 :     | appPat (CONSpat(id,NONE),p) = CONSpat(id,SOME p)
45 :     | appPat (p1,p2) = (err(loc,"pattern "^p2s p1^" "^p2s p2); p1)
46 :     in Prec.parse{error=precErr err loc,app=appPat,tuple=TUPLEpat,
47 :     id=IDpat, stack= !precStack, kind="pattern",
48 :     toString=p2s} toks
49 :     end
50 :    
51 :     fun parseFunPat precStack err loc toks =
52 :     let fun pr(SOME f,ps) = f^" "^ps2s ps
53 :     | pr(NONE, ps) = ps2s ps
54 :     fun appPat ((f,ps), (NONE,ps')) = (f, ps@ps')
55 :     | appPat ((f,ps), (SOME g,ps')) = (f, ps@[IDpat g]@ps')
56 :     (*| appPat (p1,p2) = (err(loc,"fun pattern ("^pr p1^") "^pr p2); p1)*)
57 :     fun lower(NONE,[p]) = p
58 :     | lower(SOME f,[]) = IDpat f
59 :     fun tuple ps = (NONE,[TUPLEpat(map lower ps)])
60 :     fun id n = (SOME n,[])
61 :     fun toString(NONE,ps) = ps2s ps
62 :     | toString(SOME f,ps) = f^" "^ps2s ps
63 :     in Prec.parse{error=precErr err loc,
64 :     app=appPat,
65 :     tuple=tuple,
66 :     id=id,
67 :     stack= !precStack,
68 :     kind="function argument",
69 :     toString=toString
70 :     } (map (fn Prec.EXP p => Prec.EXP(NONE,[p])
71 :     | Prec.ID id => Prec.ID id
72 :     ) toks)
73 :     end
74 :    
75 :    
76 :     fun markdecl srcMap (decl,left,right) =
77 :     MARKdecl(SourceMap.location srcMap (left,right), decl)
78 :     fun markexp srcMap (exp,left,right) =
79 :     MARKexp(SourceMap.location srcMap (left,right), exp)
80 :    
81 :     exception Bad
82 :    
83 :     fun enumPat(err, loc, id, ps) =
84 :     map (fn IDpat x => IDpat(id^x)
85 :     | p => (err(loc,"bad pattern "^PP.text(AstPP.pat p)); p)
86 :     ) ps
87 :     fun enumPat'(err, loc, ps, id) =
88 :     map (fn IDpat x => IDpat(x^id)
89 :     | p => (err(loc,"bad pattern "^PP.text(AstPP.pat p)); p)
90 :     ) ps
91 :    
92 :     fun enumExp(err, loc, id, es) =
93 :     map (fn IDexp(IDENT([],x)) => IDexp(IDENT([],id^x))
94 :     | e => (err(loc,"bad expression "^PP.text(AstPP.exp e)); e)
95 :     ) es
96 :     fun enumExp'(err, loc, es, id) =
97 :     map (fn IDexp(IDENT([],x)) => IDexp(IDENT([],x^id))
98 :     | e => (err(loc,"bad expression "^PP.text(AstPP.exp e)); e)
99 :     ) es
100 :    
101 :     %%
102 :     %header (functor MDLParser(structure Token : TOKEN
103 :     structure AstPP : MDL_AST_PRETTY_PRINTER
104 :     )
105 :     )
106 :    
107 :     %arg (srcMap,err,import,precStack,extraCells)
108 :     : SourceMap.sourcemap * (SourceMap.location * string -> unit) *
109 :     (SourceMap.location * string -> decl list) *
110 :     PrecedenceParser.precedence_stack ref *
111 :     Ast.storagedecl list
112 :     %name MDL
113 :     %term ARCHITECTURE | END | LOCAL | IN | OF | CASE | DATATYPE |
114 :     TYPE | EQ | DOLLAR | TIMES | AND | DEREF | NOT | CONCAT |
115 :     LLBRACKET | RRBRACKET |
116 :     LPAREN | RPAREN | LBRACKET | RBRACKET | LBRACE | RBRACE | SEMICOLON |
117 :     LDQUOTE | RDQUOTE | LMETA | RMETA |
118 :     CELLSET | FN | STORAGE | LOCATIONS | HASH |
119 :     COMMA | COLON | DOT | DOTDOT | AT | BAR | ARROW | DARROW | PAR | BITS |
120 :     IF | THEN | ELSE | TRUE | FALSE | WILD | RAISE |
121 :     HANDLE | LET | STRUCTURE | FUNCTOR | SIGNATURE | SIG | STRUCT | WHERE |
122 :     SHARING | INSTRUCTION | REGISTER | CELL | CELLS | ORDERING |
123 :     FIELD | FIELDS | VLIW | SUPERSCALAR | SIGNED | UNSIGNED |
124 :     FORMATS | AS | ENCODING | WITHTYPE | FUN | VAL | INCLUDE | OPEN |
125 :     LITTLE | BIG | ENDIAN | PIPELINE | PREDICATED |
126 :     LOWERCASE | UPPERCASE | VERBATIM | WHEN | BRANCHING | TAKEN |
127 :     ASSEMBLY | RTL | SPAN | DEPENDENT | ASSIGN | DELAYSLOT |
128 :     FORWARDS | ALWAYS | NEVER | BACKWARDS |
129 :     CANDIDATE | NONFIX | INFIX | INFIXR | DEBUG |
130 :     ASM_COLON | MC_COLON | RTL_COLON | DELAYSLOT_COLON | NULLIFIED_COLON |
131 :     PADDING_COLON | CANDIDATE_COLON | AGGREGABLE | ALIASING |
132 :     RESOURCE | CPU | RESERVATION | TABLE | LATENCY | EQUATION |
133 :     ID of string |
134 :     SYMBOL of string |
135 :     TYVAR of string |
136 :     WORD of Word32.word |
137 :     INT of int |
138 :     STRING of string |
139 :     CHAR of char |
140 :     ASMTEXT of string |
141 :     EOF
142 :    
143 :     %nonterm architecture of decl list |
144 :     structexp of structexp |
145 :     opt_of of unit |
146 :     id of id |
147 :     sym of id |
148 :     symb of id |
149 :     ident of ident |
150 :     ident2 of ident |
151 :     tid of id |
152 :     tid2 of id |
153 :     tident of ident |
154 :     tpath of id list * id |
155 :     idents of ident list |
156 :     syms of id list |
157 :     path of id list |
158 :     decls of decl list |
159 :     scopeddecls of decl list |
160 :     functorarg of decl list |
161 :     scopedmldecls of decl list |
162 :     newScope of unit |
163 :     oldScope of unit |
164 :     mldecls of decl list |
165 :     decl of decl |
166 :     locdecl of loc * decl |
167 :     loc of loc |
168 :     mldecl of decl |
169 :     mymldecl of decl |
170 :     mddecl of decl |
171 :     mymddecl of decl |
172 :     sharingdecl of share |
173 :     sharingdecls of share list |
174 :     sharelist of ident list |
175 :     aexp of exp |
176 :     aexp2 of exp Prec.token |
177 :     appexp of exp Prec.token list |
178 :     exp of exp |
179 :     guard of exp option |
180 :     funguard of exp option |
181 :     region of id option |
182 :     opt_exp of exp option |
183 :     exps of exp list |
184 :     exps1 of exp list |
185 :     exps2 of exp list |
186 :     expseq of exp list |
187 :     expseq2 of exp list |
188 :     labexps0 of (id * exp) list |
189 :     labexps of (id * exp) list |
190 :     labexp of id * exp |
191 :     apat of pat |
192 :     asapat of pat |
193 :     apat2 of pat Prec.token |
194 :     apppat of pat Prec.token list |
195 :     pat of pat |
196 :     pats of pat list |
197 :     pats1 of pat list |
198 :     pats2 of pat list |
199 :     orpats2 of pat list |
200 :     labpat of id * pat |
201 :     labpats0 of (id * pat) list * bool |
202 :     labpats of (id * pat) list * bool|
203 :     of_ty of ty option |
204 :     ty of ty |
205 :     aty of ty |
206 :     appty of ty |
207 :     tys2 of ty list |
208 :     labty of id * ty |
209 :     labtys of (id * ty) list |
210 :     labtys1 of (id * ty) list |
211 :     tuplety of ty list |
212 :     signedness of signedness |
213 :     word of Word32.word |
214 :     unsignedint of Word32.word |
215 :     unsignedint_opt of Word32.word option |
216 :     width of width |
217 :     int of int |
218 :     endianess of endianess |
219 :     kind of archKind |
220 :     string of string |
221 :     char of char |
222 :     bool of bool |
223 :     slice of int * int |
224 :     slices of (int * int) list |
225 :     storagedecl of storagedecl |
226 :     aliasing of id option |
227 :     printcell of exp |
228 :     storagedecls of storagedecl list |
229 :     cellcount of int option |
230 :     locbind of locbind |
231 :     locbinds of locbind list |
232 :     field of field |
233 :     fieldid of id |
234 :     cnv of cnv |
235 :     fields of field list |
236 :     formatbind of formatbind |
237 :     formatbinds of formatbind list |
238 :     datatypebinds of datatypebind list |
239 :     datatypebind of datatypebind |
240 :     consbinds of consbind list |
241 :     consbind of consbind |
242 :     consencoding of mc option |
243 :     sdi of exp option |
244 :     latency of exp option |
245 :     pipeline of exp option |
246 :     nop of flag |
247 :     flag of flag |
248 :     flagguard of exp |
249 :     nullified of flag |
250 :     delayslot of exp option |
251 :     delayslotcandidate of exp option |
252 :     delay of delayslot |
253 :     branching of branching |
254 :     consassembly of assembly option |
255 :     typebinds of typebind list |
256 :     withtypeclause of typebind list |
257 :     typebind of typebind |
258 :     tyvar of tyvar |
259 :     tyvars of tyvar list |
260 :     tyvarseq of tyvar list |
261 :     clause of clause |
262 :     clauses of clause list |
263 :     funclause of id * clause |
264 :     funclauses of id * clause list |
265 :     funbind of funbind |
266 :     funbinds of funbind list |
267 :     valbind of valbind |
268 :     valbinds of valbind list |
269 :     assemblycase of assemblycase |
270 :     rtl of exp option |
271 :     rtlterm of rtlterm |
272 :     rtlterms of rtlterm list |
273 :     opcodeencoding of int list option |
274 :     encodingexp of int list |
275 :     encodingexps of int list |
276 :     fieldty of id option |
277 :     asms of asm list |
278 :     asm of asm |
279 :     hasasm of bool |
280 :     sigsub of sigexp -> sigexp |
281 :     sigsubs of sigexp -> sigexp |
282 :     sigexp of sigexp |
283 :     True of unit |
284 :     False of unit |
285 :     default of int * exp |
286 :     default_list of (int * exp) list |
287 :     defaults of (int * exp) list |
288 :     aggregable of bool |
289 :     bitSize of int * bool |
290 :     resourcebinds of id list |
291 :     cpubinds of cpubind list |
292 :     cpubind of cpubind |
293 :     aliases of string list |
294 :     resources of (int * id) list |
295 :     resource of (int * id) |
296 :     pipelinebinds of pipelinebind list |
297 :     pipelinebind of pipelinebind |
298 :     pipelineclauses of (id * pat * pipelineexp) list |
299 :     pipelineclause of (id * pat * pipelineexp) |
300 :     cycles0 of cycle list |
301 :     cycles of cycle list |
302 :     cycle of cycle |
303 :     latencybinds of latencybind list |
304 :     latencybind of latencybind |
305 :     latencyclauses of (id * pat * exp) list |
306 :     latencyclause of (id * pat * exp)
307 :    
308 :     %verbose
309 :     %nodefault
310 :     %pos int
311 :     %eop EOF
312 :    
313 :     %left DARROW
314 :     %left IF THEN ELSE RAISE HANDLE CASE FN OF SEMICOLON COMMA
315 :     %left DOT
316 :     %left EQ
317 :     %right ARROW
318 :     %left AT
319 :     %left TIMES
320 :     %left DEREF NOT
321 :     (* %left BITS CELL *)
322 :     (* %left BAR
323 :     %left AND*)
324 :    
325 :     (*%left DARROW *)
326 :    
327 :     %%
328 :    
329 :     architecture: decls (decls)
330 :    
331 :     decls: ([])
332 :     | decl decls (decl::decls)
333 :    
334 :     mldecls: ([])
335 :     | mldecl mldecls (mldecl::mldecls)
336 :    
337 :     decl: mldecl (mldecl)
338 :     | mddecl (mddecl)
339 :     | INCLUDE string
340 :     (SEQdecl(import
341 :     (SourceMap.location srcMap
342 :     (INCLUDEleft,stringright), string)))
343 :    
344 :     mldecl: mymldecl (markdecl srcMap (mymldecl,mymldeclleft,mymldeclright))
345 :    
346 :     mddecl: mymddecl (markdecl srcMap (mymddecl,mymddeclleft,mymddeclright))
347 :    
348 :     mymddecl: ARCHITECTURE id EQ STRUCT decls END (ARCHdecl(id,decls))
349 :     | LITTLE ENDIAN (ENDIANESSdecl LITTLE)
350 :     | BIG ENDIAN (ENDIANESSdecl BIG)
351 :     | VLIW (ARCHKINDdecl VLIW)
352 :     | SUPERSCALAR (ARCHKINDdecl SUPERSCALAR)
353 :     | assemblycase ASSEMBLY (ASSEMBLYCASEdecl assemblycase)
354 :     | INSTRUCTION FORMATS int BITS formatbinds
355 :     (FORMATdecl(SOME int,formatbinds))
356 :     | INSTRUCTION FORMATS formatbinds
357 :     (FORMATdecl(NONE,formatbinds))
358 :     | STORAGE storagedecls
359 :     (STORAGEdecl(storagedecls @ extraCells))
360 :     | LOCATIONS locbinds (LOCATIONSdecl locbinds)
361 :     | INSTRUCTION consbinds (INSTRUCTIONdecl consbinds)
362 :     | DEBUG id (DEBUGdecl id)
363 :     | RESOURCE resourcebinds (RESOURCEdecl resourcebinds)
364 :     | CPU cpubinds (CPUdecl cpubinds)
365 :     | PIPELINE pipelinebinds (PIPELINEdecl pipelinebinds)
366 :     | LATENCY latencybinds (LATENCYdecl latencybinds)
367 :    
368 :     resourcebinds: id ([id])
369 :     | id AND resourcebinds (id::resourcebinds)
370 :    
371 :     cpubinds: cpubind ([cpubind])
372 :     | cpubind AND cpubinds (cpubind::cpubinds)
373 :    
374 :     cpubind: id aliases int LBRACKET resources RBRACKET
375 :     (CPUbind{name=id,aliases=aliases,
376 :     maxIssues=int,resources=resources})
377 :    
378 :     aliases: ([])
379 :     | string aliases (string::aliases)
380 :    
381 :     resources: resource ([resource])
382 :     | resource COMMA resources (resource::resources)
383 :    
384 :     resource: int id (int,id)
385 :     | id (1,id)
386 :    
387 :     pipelinebinds: pipelinebind ([pipelinebind])
388 :     | pipelinebind AND pipelinebinds (pipelinebind::pipelinebinds)
389 :    
390 :     pipelinebind: pipelineclauses
391 :     (let val name = #1(hd pipelineclauses)
392 :     val clauses = map (fn (_,x,y) => (x,y)) pipelineclauses
393 :     in (PIPELINEbind(name, clauses)) end
394 :     )
395 :    
396 :     pipelineclauses: pipelineclause ([pipelineclause])
397 :     | pipelineclause BAR pipelineclauses
398 :     (pipelineclause::pipelineclauses)
399 :    
400 :     pipelineclause: id pat EQ LBRACKET cycles0 RBRACKET (id, pat,PIPELINE cycles0)
401 :    
402 :     cycles0: ([])
403 :     | cycles (cycles)
404 :    
405 :     cycles: cycle ([cycle])
406 :     | cycle COMMA cycles (cycle::cycles)
407 :    
408 :     cycle: id (IDcycle id)
409 :     | cycle CONCAT cycle (ORcycle(cycle1,cycle2))
410 :     | cycle TIMES int (REPEATcycle(cycle, int))
411 :     | LPAREN cycle RPAREN (cycle)
412 :    
413 :     latencybinds: latencybind ([latencybind])
414 :     | latencybind AND latencybinds (latencybind::latencybinds)
415 :    
416 :     latencybind: latencyclauses
417 :     (let val name = #1(hd latencyclauses)
418 :     val clauses = map (fn (_,x,y) => (x,y)) latencyclauses
419 :     in (LATENCYbind(name, clauses)) end
420 :     )
421 :    
422 :     latencyclauses: latencyclause ([latencyclause])
423 :     | latencyclause BAR latencyclauses
424 :     (latencyclause::latencyclauses)
425 :    
426 :     latencyclause: id pat EQ exp (id, pat, exp)
427 :    
428 :     mymldecl: DATATYPE datatypebinds withtypeclause
429 :     (DATATYPEdecl(datatypebinds,withtypeclause))
430 :     | TYPE typebinds (DATATYPEdecl([],typebinds))
431 :     | FUN funbinds (FUNdecl(funbinds))
432 :     | RTL id LBRACE labpats0 RBRACE EQ exp
433 :     (RTLdecl(IDpat id,LAMBDAexp
434 :     [CLAUSE([RECORDpat labpats0],NONE,exp)],
435 :     SourceMap.location srcMap (RTLleft, expright)))
436 :     | RTL asapat EQ exp
437 :     (RTLdecl(asapat,exp,
438 :     SourceMap.location srcMap (RTLleft,expright)))
439 :     | RTL syms COLON ty (RTLSIGdecl(syms,ty))
440 :     | VAL valbinds (VALdecl(valbinds))
441 :     | VAL syms COLON ty (VALSIGdecl(syms,ty))
442 :     | TYPE tyvarseq tid (TYPESIGdecl(tid,tyvarseq))
443 :     | LOCAL scopeddecls IN scopeddecls END
444 :     (LOCALdecl(scopeddecls1,scopeddecls2))
445 :     | STRUCTURE id EQ structexp (STRUCTUREdecl(id,[],NONE,structexp))
446 :     | STRUCTURE id COLON sigexp EQ structexp
447 :     (STRUCTUREdecl(id,[],SOME sigexp,structexp))
448 :     | STRUCTURE id COLON sigexp (STRUCTURESIGdecl(id,sigexp))
449 :     | SIGNATURE id EQ sigexp (SIGNATUREdecl(id,sigexp))
450 :     | FUNCTOR id LPAREN functorarg RPAREN EQ structexp
451 :     (STRUCTUREdecl(id,functorarg,NONE,structexp))
452 :     | FUNCTOR id LPAREN functorarg RPAREN COLON sigexp EQ structexp
453 :     (STRUCTUREdecl(id,functorarg,SOME sigexp,structexp))
454 :     | SHARING sharingdecls (SHARINGdecl sharingdecls)
455 :     | INFIX int syms (Infix precStack (int,syms); INFIXdecl(int,syms))
456 :     | INFIXR int syms (Infixr precStack (int,syms); INFIXRdecl(int,syms))
457 :     | NONFIX syms (Nonfix precStack (syms); NONFIXdecl(syms))
458 :     | OPEN idents (OPENdecl(idents))
459 :    
460 :    
461 :     functorarg: scopeddecls (scopeddecls)
462 :     | id COLON sigexp ([FUNCTORARGdecl(id,sigexp)])
463 :    
464 :     sigexp: ident (IDsig ident)
465 :     | SIG decls END (DECLsig decls)
466 :     | sigexp WHERE sigsubs (sigsubs sigexp)
467 :    
468 :     sigsubs: sigsub (sigsub)
469 :     | sigsub AND sigsubs (sigsub o sigsubs)
470 :    
471 :     sigsub: TYPE ident EQ ty (fn s => WHERETYPEsig(s,ident,ty))
472 :     | ident EQ structexp (fn s => WHEREsig(s,ident,structexp))
473 :    
474 :     sharingdecls: sharingdecl ([sharingdecl])
475 :     | sharingdecl AND sharingdecls (sharingdecl::sharingdecls)
476 :    
477 :     sharingdecl: TYPE sharelist (TYPEshare sharelist)
478 :     | sharelist (STRUCTshare sharelist)
479 :    
480 :     sharelist: ident EQ ident ([ident1,ident2])
481 :     | ident EQ sharelist (ident::sharelist)
482 :    
483 :     scopedmldecls: newScope mldecls oldScope (mldecls)
484 :    
485 :     scopeddecls: newScope decls oldScope (decls)
486 :    
487 :     newScope: (newScope precStack)
488 :     oldScope: (oldScope precStack)
489 :    
490 :     syms: sym ([sym])
491 :     | sym syms (sym::syms)
492 :    
493 :     idents: ident ([ident])
494 :     | ident idents (ident::idents)
495 :    
496 :     assemblycase: LOWERCASE (LOWERCASE)
497 :     | UPPERCASE (UPPERCASE)
498 :     | VERBATIM (VERBATIM)
499 :    
500 :     rtl: RTL_COLON exp (SOME(exp))
501 :     | (NONE)
502 :    
503 :     rtlterms: rtlterm ([rtlterm])
504 :     | rtlterm rtlterms (rtlterm::rtlterms)
505 :    
506 :     rtlterm: string (LITrtl string)
507 :     | sym (IDrtl sym)
508 :     | HASH id (COMPOSITErtl id)
509 :    
510 :     structexp: ident (IDsexp ident)
511 :     | ident LPAREN scopeddecls RPAREN (APPsexp(ident,DECLsexp scopeddecls))
512 :     | ident LPAREN ident RPAREN (APPsexp(ident1,IDsexp ident2))
513 :     | STRUCT scopeddecls END (DECLsexp scopeddecls)
514 :    
515 :     datatypebinds: datatypebind ([datatypebind])
516 :     | datatypebind AND datatypebinds (datatypebind::datatypebinds)
517 :    
518 :     datatypebind: tyvarseq id opcodeencoding fieldty hasasm EQ consbinds
519 :     (let val a = hasasm orelse
520 :     List.exists(fn CONSbind{asm=SOME _,...}=>true
521 :     | _ => false) consbinds
522 :     in
523 :     DATATYPEbind{id=id,tyvars=tyvarseq,mc=opcodeencoding,
524 :     asm=a,field=fieldty,cbs=consbinds}
525 :     end
526 :     )
527 :     | tyvarseq id opcodeencoding fieldty hasasm EQ DATATYPE ty
528 :     (DATATYPEEQbind{id=id,tyvars=tyvarseq,ty=ty})
529 :    
530 :     hasasm: DEREF (true)
531 :     | (false)
532 :    
533 :     fieldty: (NONE)
534 :     | COLON id (SOME id)
535 :    
536 :     opcodeencoding: (NONE)
537 :     | LBRACKET encodingexps RBRACKET (SOME encodingexps)
538 :    
539 :     encodingexps: encodingexp (encodingexp)
540 :     | encodingexp COMMA encodingexps (encodingexp@encodingexps)
541 :    
542 :     encodingexp: int ([int])
543 :     | int DOTDOT int
544 :     (let fun f i = if i > int2 then [] else i::f(i+1)
545 :     in f int1 end)
546 :     | int int DOTDOT int
547 :     (let val inc = int2 - int1
548 :     fun f i = if i > int3 then [] else i::f(i+inc)
549 :     in f int1 end)
550 :    
551 :     consbinds: consbind ([consbind])
552 :     | consbind BAR consbinds (consbind::consbinds)
553 :    
554 :     consbind: sym of_ty consassembly consencoding rtl nop
555 :     nullified delayslot delayslotcandidate sdi latency pipeline
556 :     (let val cand =
557 :     case delayslotcandidate of
558 :     SOME _ => delayslotcandidate
559 :     | _ => case (nop,nullified) of
560 :     (FLAGoff,FLAGoff) => NONE
561 :     | _ => (SOME(BOOLexp false))
562 :     in
563 :     CONSbind{id=sym,ty=of_ty,mc=consencoding,
564 :     asm=consassembly,rtl=rtl,
565 :     nop=nop,sdi=sdi,nullified=nullified,
566 :     delayslot=delayslot,
567 :     delaycand=cand, latency=latency, pipeline=pipeline,
568 :     loc=SourceMap.location srcMap (symleft,sdiright)
569 :     }
570 :     end
571 :     )
572 :    
573 :     latency: LATENCY COLON exp (SOME exp)
574 :     | (NONE)
575 :    
576 :     pipeline: PIPELINE COLON exp (SOME exp)
577 :     | (NONE)
578 :    
579 :     delayslotcandidate: (NONE)
580 :     | DELAYSLOT CANDIDATE_COLON exp (SOME exp)
581 :    
582 :     of_ty: (NONE)
583 :     | OF ty (SOME ty)
584 :    
585 :     nop: (FLAGoff)
586 :     | PADDING_COLON flag (flag)
587 :     | PADDING_COLON False (FLAGoff)
588 :     | PADDING_COLON True (FLAGon)
589 :    
590 :     True: TRUE ()
591 :     | ALWAYS ()
592 :    
593 :     False: FALSE ()
594 :     | NEVER ()
595 :    
596 :     flag: id flagguard (FLAGid(id,true,flagguard))
597 :     | NOT id flagguard (FLAGid(id,false,flagguard))
598 :     | id EQ True flagguard (FLAGid(id,true,flagguard))
599 :     | id EQ False flagguard (FLAGid(id,false,flagguard))
600 :    
601 :     flagguard: (BOOLexp true)
602 :     | AND exp (exp)
603 :    
604 :     nullified: (FLAGoff)
605 :     | NULLIFIED_COLON FALSE (FLAGoff)
606 :     | NULLIFIED_COLON flag (flag)
607 :    
608 :     delayslot: (NONE)
609 :     | DELAYSLOT_COLON exp (SOME exp)
610 :    
611 :     branching: BRANCHING FORWARDS (BRANCHforwards)
612 :     | BRANCHING BACKWARDS (BRANCHbackwards)
613 :    
614 :     sdi: (NONE)
615 :     | SPAN DEPENDENT exp (SOME exp)
616 :    
617 :     consencoding: (NONE)
618 :     | unsignedint (SOME(WORDmc(unsignedint)))
619 :     | LPAREN expseq RPAREN (SOME(EXPmc(SEQexp expseq)))
620 :     | LPAREN exps2 RPAREN (SOME(EXPmc(TUPLEexp exps2)))
621 :     | id LBRACE labexps0 RBRACE
622 :     (SOME(EXPmc(APPexp(IDexp(IDENT([],id)),
623 :     RECORDexp labexps0))))
624 :     | MC_COLON exp (SOME(EXPmc exp))
625 :    
626 :     consassembly: (NONE)
627 :     | string (SOME(STRINGasm string))
628 :     | LDQUOTE asms RDQUOTE (SOME(ASMasm asms))
629 :     | ASM_COLON exp (SOME(ASMasm[EXPasm exp]))
630 :    
631 :     asms: asm ([asm])
632 :     | asm asms (asm::asms)
633 :    
634 :     asm: LMETA exp RMETA (EXPasm exp)
635 :     | ASMTEXT (TEXTasm ASMTEXT)
636 :    
637 :     opt_of: ()
638 :     | OF ()
639 :    
640 :     withtypeclause: ([])
641 :     | WITHTYPE typebinds (typebinds)
642 :    
643 :    
644 :     typebinds: typebind ([typebind])
645 :     | typebind AND typebinds (typebind::typebinds)
646 :    
647 :     typebind: tyvarseq tid EQ ty (TYPEbind(tid,tyvarseq,ty))
648 :    
649 :     tyvarseq: ([])
650 :     | tyvar ([tyvar])
651 :     | LPAREN tyvars RPAREN (tyvars)
652 :    
653 :     tyvars: tyvar ([tyvar])
654 :     | tyvar COMMA tyvars (tyvar::tyvars)
655 :    
656 :     formatbinds: formatbind ([formatbind])
657 :     | formatbind BAR formatbinds (formatbind::formatbinds)
658 :    
659 :     formatbind: id opt_of LBRACE fields RBRACE opt_exp
660 :     (FORMATbind(id,fields,opt_exp))
661 :    
662 :     opt_exp: (NONE)
663 :     | EQ exp (SOME exp)
664 :    
665 :     fields: field ([field])
666 :     | field COMMA fields (field::fields)
667 :    
668 :     field: fieldid COLON cnv signedness width unsignedint_opt
669 :     (FIELD{id=fieldid,cnv=cnv,
670 :     width=width,sign=signedness,value=unsignedint_opt})
671 :     | id
672 :     (FIELD{id=id,cnv=NOcnv,width=WIDTH 0,sign=UNSIGNED,value=NONE})
673 :    
674 :     fieldid: id (id)
675 :     | WILD ("")
676 :    
677 :     cnv: (NOcnv)
678 :     | id (FUNcnv id)
679 :     | DOLLAR id (CELLcnv id)
680 :    
681 :     width: (WIDTH 0)
682 :     | int (WIDTH int)
683 :     | int DOTDOT int (RANGE(int1,int2))
684 :    
685 :     unsignedint: int (Word32.fromInt int)
686 :     | word (word)
687 :    
688 :     unsignedint_opt: (NONE)
689 :     | EQ unsignedint (SOME unsignedint)
690 :    
691 :     signedness: SIGNED (SIGNED)
692 :     | UNSIGNED (UNSIGNED)
693 :     | (UNSIGNED)
694 :    
695 :     funbinds: funbind ([funbind])
696 :     | funbind AND funbinds (funbind::funbinds)
697 :    
698 :     funbind: funclauses (FUNbind funclauses)
699 :    
700 :     valbinds: valbind ([valbind])
701 :     | valbind AND valbinds (valbind::valbinds)
702 :    
703 :     valbind: pat EQ exp (VALbind(pat,exp))
704 :    
705 :     aexp: word (LITexp(WORD32lit word))
706 :     | int (LITexp(INTlit int))
707 :     | string (STRINGexp string)
708 :     | char (LITexp(CHARlit char))
709 :     | bool (BOOLexp bool)
710 :     | ident2 (IDexp ident2)
711 :     | HASH id (TYPEexp(TYVARty(INTtv id)))
712 :     | LPAREN symb RPAREN (IDexp (IDENT([],symb)))
713 :     | LPAREN exp COLON ty RPAREN (TYPEDexp(exp,ty))
714 :     | LDQUOTE asms RDQUOTE (ASMexp(ASMasm asms))
715 :     | LPAREN RPAREN (TUPLEexp [])
716 :     | LPAREN exp RPAREN (exp)
717 :     | LPAREN exps2 RPAREN (TUPLEexp exps2)
718 :     | LPAREN expseq2 RPAREN (SEQexp expseq2)
719 :     | LBRACKET exps RBRACKET (LISTexp(exps,NONE))
720 :     | LBRACE labexps0 RBRACE (RECORDexp labexps0)
721 :     | DOLLAR id LBRACKET exp region RBRACKET (LOCexp(id,exp,region))
722 :     | LLBRACKET rtlterms RRBRACKET (RTLexp(rtlterms))
723 :     | sym CONCAT LBRACKET exps RBRACKET
724 :     (let val loc = SourceMap.location srcMap
725 :     (symleft,RBRACKETright)
726 :     in LISTexp(enumExp(err,loc,sym,exps),NONE) end
727 :     )
728 :     | LBRACKET exps RBRACKET CONCAT sym
729 :     (let val loc = SourceMap.location srcMap
730 :     (symleft,RBRACKETright)
731 :     in LISTexp(enumExp'(err,loc,exps,sym),NONE) end
732 :     )
733 :    
734 :     | sym CONCAT LBRACKET exps RBRACKET CONCAT sym
735 :     (let val loc = SourceMap.location srcMap
736 :     (symleft,RBRACKETright)
737 :     in LISTexp(enumExp'(err,loc,
738 :     enumExp(err,loc,sym1,exps),sym2),
739 :     NONE)
740 :     end
741 :     )
742 :    
743 :     region: (NONE)
744 :     | COLON id (SOME id)
745 :    
746 :     aexp2: aexp (Prec.EXP aexp)
747 :     | sym (Prec.ID sym)
748 :     | EQ (Prec.ID "=")
749 :     | aexp2 AT LBRACKET slices RBRACKET
750 :     (Prec.EXP(BITSLICEexp(
751 :     case aexp2 of Prec.EXP e => e
752 :     | Prec.ID x => IDexp(IDENT([],x)),slices)))
753 :    
754 :     labexps0: ([])
755 :     | labexps (labexps)
756 :     labexps: labexp ([labexp])
757 :     | labexp COMMA labexps (labexp::labexps)
758 :    
759 :     labexp: id EQ exp (id,exp)
760 :     | id (id,IDexp(IDENT([],id)))
761 :    
762 :     appexp: aexp2 ([aexp2])
763 :     | appexp aexp2 (appexp @ [aexp2])
764 :    
765 :     exp: appexp (parseExp precStack err
766 :     (SourceMap.location srcMap (appexpleft,appexpright)) appexp)
767 :     | IF exp THEN exp ELSE exp (IFexp(exp1,exp2,exp3))
768 :     | CASE exp OF clauses (CASEexp(exp,clauses))
769 :     | FN clauses (LAMBDAexp clauses)
770 :     | exp HANDLE clauses (HANDLEexp(exp,clauses))
771 :     | RAISE exp (RAISEexp exp)
772 :     | LET decls IN expseq END (LETexp(decls,expseq))
773 :    
774 :     expseq: exp ([exp])
775 :     | exp SEMICOLON expseq (exp::expseq)
776 :    
777 :     expseq2: exp SEMICOLON expseq (exp::expseq)
778 :    
779 :     exps1: exp ([exp])
780 :     | exp COMMA exps1 (exp::exps1)
781 :    
782 :     exps2: exp COMMA exps1 (exp::exps1)
783 :    
784 :     exps: ([])
785 :     | exps1 (exps1)
786 :    
787 :     apat: ident2 (CONSpat(ident2,NONE))
788 :     | int (LITpat(INTlit int))
789 :     | word (LITpat(WORD32lit word))
790 :     | string (LITpat(STRINGlit string))
791 :     | bool (LITpat(BOOLlit bool))
792 :     | char (LITpat(CHARlit char))
793 :     | WILD (WILDpat)
794 :     | LPAREN RPAREN (TUPLEpat [])
795 :     | LBRACKET pats RBRACKET (LISTpat(pats,NONE))
796 :     | LPAREN pats2 RPAREN (TUPLEpat pats2)
797 :     | LPAREN orpats2 RPAREN (ORpat orpats2)
798 :     | LPAREN pat RPAREN (pat)
799 :     | LBRACE labpats0 RBRACE (RECORDpat(labpats0))
800 :     | sym CONCAT LBRACKET pats RBRACKET
801 :     (let val loc = SourceMap.location srcMap
802 :     (symleft,RBRACKETright)
803 :     in LISTpat(enumPat(err,loc,sym,pats),NONE) end
804 :     )
805 :     | sym CONCAT LBRACKET pats RBRACKET CONCAT sym
806 :     (let val loc = SourceMap.location srcMap
807 :     (symleft,RBRACKETright)
808 :     in LISTpat(enumPat'(err,loc,
809 :     enumPat(err,loc,sym1,pats),sym2),NONE) end
810 :     )
811 :    
812 :     | LBRACKET pats RBRACKET CONCAT sym
813 :     (let val loc = SourceMap.location srcMap
814 :     (symleft,RBRACKETright)
815 :     in LISTpat(enumPat'(err,loc,pats,sym),NONE) end
816 :     )
817 :    
818 :    
819 :     orpats2: pat BAR pat ([pat1,pat2])
820 :     | pat BAR orpats2 (pat::orpats2)
821 :    
822 :     apat2: apat (Prec.EXP apat)
823 :     | sym (Prec.ID sym)
824 :    
825 :     apppat: apat2 ([apat2])
826 :     | apppat apat2 (apppat@[apat2])
827 :    
828 :     pat: apppat (parsePat precStack err
829 :     (SourceMap.location srcMap
830 :     (apppatleft,apppatright)) apppat)
831 :     | id AS pat (ASpat(id,pat))
832 :    
833 :     asapat: apat (apat)
834 :     | id AS asapat (ASpat(id,asapat))
835 :    
836 :     pats: ([])
837 :     | pats1 (pats1)
838 :    
839 :     pats1: pat ([pat])
840 :     | pat COMMA pats1 (pat::pats1)
841 :    
842 :     pats2: pat COMMA pats1 (pat::pats1)
843 :    
844 :     labpats0: ([],false)
845 :     | labpats (labpats)
846 :    
847 :     labpats: labpat ([labpat],false)
848 :     | labpat COMMA DOTDOT ([labpat],true)
849 :     | labpat COMMA labpats (labpat:: #1 labpats, #2 labpats)
850 :    
851 :     labpat: sym (sym,IDpat sym)
852 :     | sym EQ pat (sym,pat)
853 :     | sym AS pat (sym,ASpat(sym,pat))
854 :    
855 :     clause: pat guard DARROW exp (CLAUSE([pat],guard,exp))
856 :    
857 :     guard: (NONE)
858 :     | WHERE exp (SOME exp)
859 :    
860 :     clauses: clause ([clause])
861 :     | clause BAR clauses (clause::clauses)
862 :    
863 :     funclause: apppat funguard EQ exp
864 :     (let val loc = SourceMap.location srcMap (apppatleft,expright)
865 :     in case parseFunPat precStack err loc apppat of
866 :     (SOME f,ps) => (f,CLAUSE(ps,funguard,exp))
867 :     | (NONE,ps) =>
868 :     (err(loc,
869 :     "in clause "^
870 :     PP.text(AstPP.clause (CLAUSE(ps,funguard,exp))));
871 :     ("dummy",CLAUSE(ps,funguard,exp)))
872 :     end
873 :     )
874 :    
875 :     funguard: (NONE)
876 :     | WHERE LPAREN exp RPAREN (SOME exp)
877 :    
878 :     funclauses: funclause (#1 funclause,[#2 funclause])
879 :     | funclause BAR funclauses (#1 funclause,#2 funclause:: #2 funclauses)
880 :    
881 :     aty: tident (IDty tident)
882 :     | HASH int (INTVARty int)
883 :     | tyvar (TYVARty tyvar)
884 :     | DOLLAR id (CELLty id)
885 :     | LPAREN RPAREN (IDty(IDENT([],"unit")))
886 :     | LPAREN ty RPAREN (ty)
887 :     | LBRACE labtys RBRACE (RECORDty labtys)
888 :    
889 :     appty: aty (aty)
890 :     | appty tident (APPty(tident,[appty]))
891 :     | LPAREN tys2 RPAREN tident (APPty(tident,tys2))
892 :    
893 :     tid: id (id)
894 :     | tid2 (tid2)
895 :    
896 :     tid2: BITS ("bits")
897 :     | CELL ("cell")
898 :     | INSTRUCTION ("instruction")
899 :    
900 :     tident: tid (IDENT([],tid))
901 :     | tpath (IDENT(rev(#1 tpath), #2 tpath))
902 :    
903 :     tpath: tid DOT tid ([tid1],tid2)
904 :     | tpath DOT tid (#2 tpath :: #1 tpath,tid)
905 :    
906 :    
907 :     tys2: ty COMMA ty ([ty1,ty2])
908 :     | ty COMMA tys2 (ty::tys2)
909 :    
910 :     ty: ty ARROW ty (FUNty(ty1,ty2))
911 :     | tuplety (TUPLEty tuplety)
912 :     | appty (appty)
913 :    
914 :     labtys: ([])
915 :     | labtys1 (labtys1)
916 :    
917 :     labtys1: labty ([labty])
918 :     | labty COMMA labtys1 (labty::labtys1)
919 :    
920 :     labty: id COLON ty (id,ty)
921 :    
922 :     tuplety: appty TIMES appty ([appty1,appty2])
923 :     | appty TIMES tuplety (appty::tuplety)
924 :    
925 :     storagedecls: storagedecl ([storagedecl])
926 :     | storagedecl BAR storagedecls (storagedecl::storagedecls)
927 :    
928 :     storagedecl: id EQ DOLLAR id LBRACKET cellcount RBRACKET bitSize
929 :     aliasing defaults printcell
930 :     (CELLdecl{id=id1,nickname=id2,
931 :     bits= #1 bitSize,count=cellcount,
932 :     alias= aliasing, aggregable= #2 bitSize,
933 :     from=ref 0,to=ref 0,print=printcell,
934 :     defaults=defaults})
935 :    
936 :     aggregable: (false)
937 :     | AGGREGABLE (true)
938 :    
939 :     bitSize: OF int aggregable BITS (int,aggregable)
940 :     | (0,false)
941 :    
942 :     cellcount: int (SOME int)
943 :     | (NONE)
944 :    
945 :     locbind: id EQ exp (LOCbind(id,NONE,exp))
946 :     | id pat EQ exp (LOCbind(id,SOME pat,exp))
947 :    
948 :     locbinds: locbind ([locbind])
949 :     | locbind AND locbinds (locbind::locbinds)
950 :    
951 :     word: WORD (WORD)
952 :    
953 :     int: INT (INT)
954 :    
955 :     aliasing: (NONE)
956 :     | ALIASING id (SOME id)
957 :    
958 :     printcell: ASM_COLON string
959 :     (LAMBDAexp [CLAUSE([WILDpat],NONE,
960 :     LITexp(STRINGlit string))])
961 :     | ASM_COLON LPAREN exp RPAREN (exp)
962 :    
963 :     defaults: ([])
964 :     | WHERE default_list (default_list)
965 :    
966 :     default_list: default ([default])
967 :     | default AND default_list (default::default_list)
968 :    
969 :     default: DOLLAR id LBRACKET int RBRACKET EQ exp (int,exp)
970 :    
971 :     slices: slice ([slice])
972 :     | slice COMMA slices (slice::slices)
973 :    
974 :     slice: int DOTDOT int (int1,int2)
975 :     | int (int1,int1)
976 :    
977 :     id: ID (ID)
978 :     | SYMBOL (SYMBOL)
979 :     | CELLSET ("cellset")
980 :    
981 :     sym: id (id)
982 :     | symb (symb)
983 :    
984 :     symb: TIMES ("*")
985 :     | NOT ("not")
986 :     | DEREF ("!")
987 :    
988 :     ident: id (IDENT([],id))
989 :     | ident2 (ident2)
990 :    
991 :     ident2: path (IDENT(rev(tl path),hd path))
992 :    
993 :     path: id DOT sym ([sym,id])
994 :     | path DOT sym (sym::path)
995 :    
996 :     tyvar: TYVAR (VARtv TYVAR)
997 :     | HASH id (INTtv id)
998 :    
999 :     string: STRING (STRING)
1000 :    
1001 :     char: CHAR (CHAR)
1002 :    
1003 :     bool: False (false)
1004 :     | True (true)

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