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/trunk/src/compiler/Parse/parse/ml.grm
ViewVC logotype

Annotation of /sml/trunk/src/compiler/Parse/parse/ml.grm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 651 - (view) (download)

1 : monnier 16 (* ml.grm
2 :     *
3 :     * Copyright 1989,1992 by AT&T Bell Laboratories
4 :     *)
5 :    
6 :     open Ast ErrorMsg Symbol FastSymbol AstUtil Fixity
7 :    
8 :     type raw_symbol = FastSymbol.raw_symbol
9 :    
10 :     fun markexp (e as MarkExp _, _, _) = e
11 :     | markexp(e,a,b) = MarkExp(e,(a,b))
12 :     (*fun markdec((d as MarkDec _, e), _,_) = (d,e)
13 :     | markdec((d,e),a,b) = (MarkDec(d,(a,b)),e)
14 :     *)
15 :     fun markdec(d as MarkDec _, _,_) = d
16 :     | markdec(d,a,b) = MarkDec(d,(a,b))
17 :    
18 : monnier 422 val asteriskHash = HashString.hashString "*"
19 : monnier 16 val asteriskString = "*"
20 : monnier 422 val equalHash = HashString.hashString "="
21 : monnier 16 val equalString = "="
22 : monnier 422 val bogusHash = HashString.hashString "BOGUS"
23 : monnier 16 val bogusString = "BOGUS"
24 : monnier 422 val quotedBogusHash = HashString.hashString "'BOGUS"
25 : monnier 16 val quotedBogusString = "'BOGUS"
26 : monnier 422 val quotedBogusHash = HashString.hashString "'BOGUS"
27 : monnier 16 val quotedBogusString = "'BOGUS"
28 :    
29 :     %%
30 :     %term
31 :     EOF | SEMICOLON
32 :     | ID of FastSymbol.raw_symbol | TYVAR of FastSymbol.raw_symbol
33 :     | INT of IntInf.int | INT0 of IntInf.int
34 :     | WORD of IntInf.int
35 :     | REAL of string
36 :     | STRING of string
37 :     | CHAR of string
38 :     | ABSTYPE | AND
39 : league 83 | ARROW | AS | BAR | CASE | DATATYPE | DOTDOTDOT | ELSE | END | EQUALOP
40 : monnier 16 | EQTYPE | EXCEPTION | DO | DOT | DARROW | FN | FUN | FUNCTOR | HANDLE
41 :     | HASH | IF | IN | INCLUDE | INFIX | INFIXR | LAZY | LET | LOCAL | NONFIX | OF
42 :     | OP | OPEN | OVERLOAD | RAISE | REC | SHARING | SIG | SIGNATURE | STRUCT
43 :     | STRUCTURE | THEN | TYPE | VAL | WHERE | WHILE | WILD | WITH | WITHTYPE
44 :     | ASTERISK | COLON | COLONGT | COMMA | LBRACE | LBRACKET | LPAREN | RBRACE
45 :     | RBRACKET | RPAREN | ORELSE | ANDALSO | FUNSIG | VECTORSTART | BEGINQ
46 :     | ENDQ of string | OBJL of string | AQID of FastSymbol.raw_symbol
47 :    
48 :     %nonterm ident of FastSymbol.raw_symbol
49 :     | id of FastSymbol.raw_symbol
50 :     | int of IntInf.int
51 :     | op_op of unit
52 :     | qid of (FastSymbol.raw_symbol ->symbol) -> symbol list
53 :     | selector of symbol
54 :     | tycon of symbol list
55 :     | tlabel of (symbol * ty)
56 :     | tlabels of (symbol * ty) list
57 :     | ty' of ty
58 :     | tuple_ty of ty list
59 :     | ty of ty
60 :     | ty0_pc of ty list
61 :     | match of rule list
62 :     | rule of rule
63 :     | elabel of (symbol * exp)
64 :     | elabels of (symbol * exp) list
65 :     | exp_ps of exp list
66 :     | exp of exp
67 :     | app_exp of exp fixitem list
68 :     | aexp of exp
69 :     | exp_list of exp list
70 :     | exp_2c of exp list
71 :     | quote of exp list
72 :     | ot_list of exp list
73 :     | pat of pat
74 :     | apat of pat fixitem
75 :     | apat' of pat
76 :     | plabel of (symbol * pat)
77 :     | plabels of ((symbol * pat) list * bool)
78 :     | pat_2c of pat list
79 :     | pat_list of pat list
80 :     | or_pat_list of pat list
81 :     | vb of vb list
82 :     | constraint of ty option
83 :     | rvb of rvb list
84 :     | fb' of clause list
85 :     | fb of fb list
86 :     | apats of pat fixitem list
87 :     | clause of clause
88 :     | tb of tb list
89 :     | tyvars of tyvar list
90 :     | tyvarseq of tyvar list
91 :     | tyvar_pc of tyvar list
92 :     | db of db list
93 :     | dbrhs of dbrhs
94 :     | constrs of (symbol * ty option) list
95 :     | constr of symbol * ty option
96 :     | eb of eb list
97 :     | qid_p of Symbol.symbol list list
98 :     | fixity of fixity
99 :     | ldec of dec
100 :     | exp_pa of exp list
101 :     | ldecs of dec
102 :     | ops of symbol list
103 :     | spec_s of spec list
104 :     | spec of spec list
105 :     | idents of spec list
106 :     | strspec of (symbol * sigexp * path option) list
107 :     | fctspec of (symbol * fsigexp) list
108 :     | tyspec of (symbol * tyvar list * ty option) list
109 :     | valspec of (symbol * ty) list
110 :     | exnspec of (symbol * ty option) list
111 :     | sharespec of spec list
112 :     | patheqn of (FastSymbol.raw_symbol ->symbol) -> symbol list list
113 :     | whspec of wherespec list
114 :     | sign of sigexp
115 :     | sigconstraint_op of sigexp sigConst
116 :     | fsigconstraint_op of fsigexp sigConst
117 :     | sigb of sigb list
118 :     | fsigb of fsigb list
119 :     | fsig of fsigexp
120 :     | str of strexp
121 :     | arg_fct of (strexp * bool) list
122 :     | strdec of dec
123 :     | strdecs of dec
124 :     | sdec of dec
125 :     | sdecs of dec
126 :     | sdecs' of dec
127 :     | strb of strb list
128 :     | fparam of symbol option * sigexp
129 :     | fparamList of (symbol option * sigexp) list
130 :     | fctb of fctb list
131 :     | fct_exp of fsigexp sigConst -> fctexp
132 :     | interdec of dec
133 :    
134 :     %verbose
135 :     %pos int
136 :     %arg (error) : pos * pos -> ErrorMsg.complainer
137 :     %start interdec
138 :     %eop EOF SEMICOLON
139 :     %noshift EOF
140 :    
141 :     %nonassoc WITHTYPE
142 :     %right AND
143 :     %right ARROW
144 :     %right DARROW
145 :     %left DO
146 :     %left ELSE
147 :     %left RAISE
148 :     %right HANDLE
149 : monnier 582 %right ORELSE
150 :     %right ANDALSO
151 : monnier 16 %right AS
152 :     %left COLON
153 :    
154 :    
155 :     %name ML
156 :    
157 : league 83 %keyword ABSTYPE AND AS CASE DATATYPE DOTDOTDOT ELSE END
158 : monnier 16 EQTYPE EXCEPTION DO DARROW FN FUN FUNCTOR HANDLE
159 :     IF IN INCLUDE INFIX INFIXR LAZY LET LOCAL NONFIX OF OP
160 :     OPEN OVERLOAD RAISE REC SHARING SIG SIGNATURE STRUCT
161 :     STRUCTURE THEN TYPE VAL WHILE WHERE WITH WITHTYPE
162 :     ORELSE ANDALSO
163 :    
164 :     %change -> VAL | -> THEN | -> ELSE | -> LPAREN | -> SEMICOLON |
165 :     DARROW -> EQUALOP | EQUALOP -> DARROW | AND -> ANDALSO | COLON -> OF |
166 :     SEMICOLON -> COMMA | COMMA -> SEMICOLON |
167 :     -> IN ID END | -> ELSE ID
168 :    
169 :     %value ID (rawSymbol(bogusHash,bogusString))
170 :     %value TYVAR (rawSymbol(quotedBogusHash,quotedBogusString))
171 :     %value INT (IntInf.fromInt 1)
172 :     %value INT0 (IntInf.fromInt 0)
173 :     %value WORD (IntInf.fromInt 0)
174 :     %value REAL ("0.0")
175 :     %value STRING ("")
176 :     %value CHAR ("a")
177 :    
178 :     %%
179 :    
180 :     int : INT (INT)
181 :     | INT0 (INT0)
182 :    
183 :     id : ID (ID)
184 :     | ASTERISK (rawSymbol (asteriskHash,asteriskString))
185 :    
186 :     ident : ID (ID)
187 :     | ASTERISK (rawSymbol (asteriskHash,asteriskString))
188 :     | EQUALOP (rawSymbol (equalHash,equalString))
189 :    
190 :     op_op : OP (error (OPleft,OPright) WARN "unnecessary `op'"
191 :     nullErrorBody)
192 :     | ()
193 :    
194 :     qid : ID DOT qid (fn kind => strSymbol ID :: qid kind)
195 :     | ident (fn kind => [kind ident])
196 :    
197 :     selector: id (labSymbol id)
198 :     | INT (Symbol.labSymbol(IntInf.toString INT))
199 :    
200 :     tycon : ID DOT tycon (strSymbol ID :: tycon)
201 :     | ID ([tycSymbol ID])
202 :    
203 :     tlabel : selector COLON ty (selector, ty )
204 :    
205 :     tlabels : tlabel COMMA tlabels (tlabel :: tlabels)
206 :     | tlabel ([tlabel])
207 :    
208 :     ty' : TYVAR (MarkTy (VarTy(Tyv(tyvSymbol TYVAR)),
209 :     (TYVARleft,TYVARright)))
210 :     | LBRACE tlabels
211 :     RBRACE (MarkTy(RecordTy tlabels,(LBRACEleft,RBRACEright)))
212 :     | LBRACE RBRACE (RecordTy [])
213 :     | LPAREN ty0_pc RPAREN tycon
214 :     (MarkTy(ConTy(tycon,ty0_pc),(tyconleft,tyconright)))
215 :     | LPAREN ty RPAREN (ty)
216 :     | ty' tycon (MarkTy(ConTy(tycon,[ty']),(tyconleft,tyconright)))
217 :     | tycon (MarkTy(ConTy(tycon,[]),(tyconleft,tyconright)))
218 :    
219 :     tuple_ty : ty' ASTERISK tuple_ty (ty' :: tuple_ty)
220 :     | ty' ASTERISK ty' ([ty'1,ty'2])
221 :    
222 :     ty : tuple_ty (TupleTy(tuple_ty))
223 :     | ty ARROW ty (ConTy([arrowTycon], [ty1,ty2]))
224 :     | ty' (ty')
225 :    
226 :     ty0_pc : ty COMMA ty ([ty1,ty2])
227 :     | ty COMMA ty0_pc (ty :: ty0_pc)
228 :    
229 :     match : rule ([rule])
230 :     | rule BAR match (rule :: match)
231 :    
232 :     rule : pat DARROW exp (Rule{pat=pat,
233 :     exp=markexp(exp,expleft,expright)})
234 :    
235 :     (* EXPRESSIONS *)
236 :    
237 :     elabel : selector EQUALOP exp (selector,exp)
238 :    
239 :     elabels : elabel COMMA elabels (elabel :: elabels)
240 :     | elabel ([elabel])
241 :    
242 :     exp_ps : exp ([exp])
243 :     | exp SEMICOLON exp_ps (exp :: exp_ps)
244 :    
245 :     exp : exp HANDLE match (HandleExp{expr=exp,rules=match})
246 :    
247 :     | exp ORELSE exp (OrelseExp(markexp(exp1,exp1left,exp1right),
248 :     markexp(exp2,exp2left,exp2right)))
249 :     | exp ANDALSO exp (AndalsoExp(markexp(exp1,exp1left,exp1right),
250 :     markexp(exp2,exp2left,exp2right)))
251 :     | exp COLON ty (ConstraintExp{expr=exp,constraint=ty})
252 :     | app_exp (FlatAppExp(app_exp))
253 :     | FN match (markexp(FnExp match, FNleft,matchright))
254 :     | CASE exp OF match (markexp(CaseExp{expr=exp, rules=match},
255 :     CASEleft,matchright))
256 :     | WHILE exp DO exp (WhileExp
257 :     {test=markexp(exp1, exp1left, exp1right),
258 :     expr=markexp(exp2, exp2left, exp2right)})
259 :     | IF exp THEN exp ELSE exp (IfExp{test=exp1,
260 :     thenCase=markexp(exp2,exp2left,exp2right),
261 :     elseCase=markexp(exp3,exp3left,exp3right)})
262 :     | RAISE exp (markexp(markexp(RaiseExp exp, expleft,expright),
263 :     RAISEleft,expright))
264 :    
265 :     app_exp : aexp ([{item=markexp(aexp,aexpleft,aexpright),
266 :     region=(aexpleft,aexpright), fixity=NONE}])
267 :     | ident ([let val (v,f) = var'n'fix ident
268 :     in {item=markexp(VarExp [v],identleft,identright),
269 :     region=(identleft,identright),
270 :     fixity=SOME f}
271 :     end])
272 :     | aexp app_exp ({item=markexp(aexp,aexpleft,aexpright),
273 :     region=(aexpleft,aexpright), fixity=NONE}
274 :     :: app_exp)
275 :     | ident app_exp (let val (v,f) = var'n'fix ident
276 :     in {item=markexp(VarExp [v],identleft,identright),
277 :     region=(identleft,identright),
278 :     fixity=SOME f} :: app_exp
279 :     end)
280 :    
281 :     aexp : OP ident (VarExp [varSymbol ident])
282 :     | ID DOT qid (VarExp (strSymbol ID :: qid varSymbol))
283 :     | int (IntExp int)
284 :     | WORD (WordExp WORD)
285 :     | REAL (RealExp REAL)
286 :     | STRING (StringExp STRING)
287 :     | CHAR (CharExp CHAR)
288 :     | HASH selector (markexp(SelectorExp selector,
289 :     HASHleft, selectorright))
290 :     | LBRACE elabels RBRACE (markexp(RecordExp elabels,
291 :     LBRACEleft,RBRACEright))
292 :     | LBRACE RBRACE (RecordExp nil)
293 :     | LPAREN RPAREN (unitExp)
294 :     | LPAREN exp_ps RPAREN (SeqExp exp_ps)
295 :     | LPAREN exp_2c RPAREN (TupleExp exp_2c)
296 :     | LBRACKET exp_list RBRACKET (ListExp exp_list)
297 :     | LBRACKET RBRACKET (ListExp nil)
298 :     | VECTORSTART exp_list RBRACKET (VectorExp exp_list)
299 :     | VECTORSTART RBRACKET (VectorExp nil)
300 :     | LET ldecs IN exp_ps END
301 :     (markexp (LetExp{dec=markdec(ldecs,ldecsleft,
302 :     ldecsright),
303 :     expr=SeqExp exp_ps},
304 :     LETleft,ENDright))
305 :     | AQID (VarExp([varSymbol AQID]))
306 :     | quote (ListExp quote)
307 :    
308 :     quote : BEGINQ ENDQ ([QuoteExp ENDQ])
309 :     | BEGINQ ot_list ENDQ (ot_list @ [QuoteExp ENDQ])
310 :    
311 :     ot_list : OBJL aexp ([QuoteExp OBJL,AntiquoteExp aexp])
312 :     | OBJL aexp ot_list (QuoteExp OBJL :: AntiquoteExp aexp ::
313 :     ot_list)
314 :    
315 :     exp_2c : exp COMMA exp_2c (exp :: exp_2c)
316 :     | exp COMMA exp ([exp1, exp2])
317 :    
318 :     exp_list : exp ([exp])
319 :     | exp COMMA exp_list (exp :: exp_list)
320 :    
321 :     pat : pat AS pat (layered(pat1, pat2,
322 :     error(pat1left,pat2right)))
323 :     | pat COLON ty (ConstraintPat{pattern=pat, constraint=ty})
324 :     | apats (FlatAppPat apats)
325 :    
326 :     apat : apat' ({item=apat', region=(apat'left,apat'right),
327 :     fixity=NONE})
328 :     | LPAREN pat RPAREN ({item=pat,
329 :     region=(LPARENleft,RPARENright),
330 :     fixity=NONE})
331 :     | id (let val (v,f) = var'n'fix id
332 :     in {item=VarPat [v],
333 :     region=(idleft,idright),
334 :     fixity=SOME f} end)
335 :     | LPAREN RPAREN ({item=unitPat,fixity=NONE,
336 :     region=(LPARENleft,RPARENright)})
337 :     | LPAREN pat COMMA pat_list RPAREN
338 :     ({item=TuplePat(pat :: pat_list),
339 :     region=(LPARENleft,RPARENright),
340 :     fixity=NONE})
341 :     | LPAREN pat BAR or_pat_list RPAREN
342 :     ({item=OrPat(pat :: or_pat_list),
343 :     region=(LPARENleft,RPARENright),
344 :     fixity=NONE})
345 :    
346 :     apat' : OP ident (VarPat [varSymbol ident])
347 :     | ID DOT qid (VarPat (strSymbol ID :: qid varSymbol))
348 :     | int (IntPat int)
349 :     | WORD (WordPat WORD)
350 :     | STRING (StringPat STRING)
351 :     | CHAR (CharPat CHAR)
352 :     | WILD (WildPat)
353 :     | LBRACKET RBRACKET (ListPat nil)
354 :     | LBRACKET pat_list
355 :     RBRACKET (ListPat pat_list)
356 :     | VECTORSTART RBRACKET (VectorPat nil)
357 :     | VECTORSTART pat_list
358 :     RBRACKET (VectorPat pat_list)
359 :     | LBRACE RBRACE (unitPat)
360 :     | LBRACE plabels RBRACE
361 :     (let val (d,f) = plabels
362 :     in MarkPat(RecordPat{def=d,flexibility=f},
363 :     (LBRACEleft,RBRACEright)) end)
364 :    
365 :     plabel : selector EQUALOP pat ((selector,pat))
366 :     | ID (labSymbol ID, VarPat [varSymbol ID])
367 :     | ID AS pat (labSymbol ID,
368 :     LayeredPat{varPat=VarPat [varSymbol ID],
369 :     expPat=pat})
370 :     | ID COLON ty (labSymbol ID,
371 :     ConstraintPat{pattern=VarPat [varSymbol ID],
372 :     constraint=ty})
373 :     | ID COLON ty AS pat (labSymbol ID,
374 :     LayeredPat
375 :     {varPat=ConstraintPat{pattern=VarPat [varSymbol ID],
376 :     constraint=ty},
377 :     expPat=pat})
378 :    
379 :     plabels : plabel COMMA plabels (let val (a,(b,fx))=(plabel, plabels)
380 :     in (a::b, fx) end)
381 :     | plabel ([plabel],false)
382 :     | DOTDOTDOT (nil, true)
383 :    
384 :     pat_list: pat ([pat])
385 :     | pat COMMA pat_list (pat :: pat_list)
386 :    
387 :     or_pat_list : pat ([pat])
388 :     | pat BAR or_pat_list (pat :: or_pat_list)
389 :    
390 :     vb : vb AND vb (vb1 @ vb2)
391 : monnier 109 | LAZY pat EQUALOP exp ([MarkVb(Vb{exp=exp, pat=pat, lazyp=true},
392 :     (patleft,expright))])
393 :     | pat EQUALOP exp ([MarkVb(Vb{exp=exp, pat=pat, lazyp=false},
394 :     (patleft,expright))])
395 : monnier 16
396 :     constraint : (NONE)
397 :     | COLON ty (SOME ty)
398 :    
399 :     rvb : id constraint EQUALOP exp
400 :     (let val (v,f) = var'n'fix id
401 :     in [MarkRvb(Rvb{var=v,fixity=SOME(f,(idleft,idright)),
402 :     resultty=constraint,
403 : monnier 109 exp=exp,lazyp=false},
404 :     (idleft,expright))]
405 :     end)
406 : monnier 16 | OP id constraint EQUALOP exp
407 :     ([MarkRvb(Rvb{var=varSymbol id,fixity=NONE,
408 : monnier 109 resultty=constraint,
409 :     exp=exp,lazyp=false},
410 :     (OPleft,expright))])
411 :     | rvb AND rvb (rvb1 @ rvb2)
412 : monnier 16 | LAZY id constraint EQUALOP exp
413 :     (let val (v,f) = var'n'fix id
414 : monnier 109 in [MarkRvb(Rvb{var=v,fixity=SOME(f,(idleft,idright)),
415 : monnier 16 resultty=constraint,
416 : monnier 109 exp=exp,lazyp=true},
417 :     (idleft,expright))]
418 :     end)
419 : monnier 16 | LAZY OP id constraint EQUALOP exp
420 : monnier 109 ([MarkRvb(Rvb{var=varSymbol id,fixity=NONE,
421 :     resultty=constraint,
422 :     exp=exp,lazyp=true},
423 :     (OPleft,expright))])
424 : monnier 16
425 :    
426 :     fb' : clause ([clause])
427 :     | clause BAR fb' (clause :: fb')
428 :    
429 : monnier 109 fb : fb' ([MarkFb(Fb(fb',false), (fb'left,fb'right))])
430 :     | LAZY fb' ([MarkFb(Fb(fb',true), (fb'left,fb'right))])
431 :     | fb' AND fb (MarkFb(Fb(fb',false), (fb'left,fb'right)) :: fb)
432 :     | LAZY fb' AND fb (MarkFb(Fb(fb',true), (fb'left,fb'right)) :: fb)
433 : monnier 16
434 :     apats : apat ([apat])
435 :     | apat apats (apat :: apats)
436 :    
437 :     clause : apats constraint EQUALOP exp
438 :     (Clause{pats=apats,
439 :     resultty=constraint,
440 :     exp=markexp(exp,expleft,expright)})
441 :    
442 :    
443 :     tb : tyvars ID EQUALOP ty ([MarkTb(
444 :     Tb{tyvars=tyvars,tyc=tycSymbol ID,def=ty},
445 :     (tyleft,tyright))])
446 :     | tb AND tb (tb1 @ tb2)
447 :    
448 :     tyvars : TYVAR ([MarkTyv(Tyv(tyvSymbol TYVAR),
449 :     (TYVARleft,TYVARright))])
450 :     | LPAREN tyvar_pc RPAREN (tyvar_pc)
451 :     | (nil)
452 :    
453 :     tyvarseq: TYVAR ([MarkTyv(Tyv(tyvSymbol TYVAR),
454 :     (TYVARleft,TYVARright))])
455 :     | LPAREN tyvar_pc RPAREN (tyvar_pc)
456 :    
457 :     tyvar_pc: TYVAR ([MarkTyv(Tyv(tyvSymbol TYVAR), (TYVARleft,TYVARright))])
458 :     | TYVAR COMMA tyvar_pc
459 :     (MarkTyv(Tyv(tyvSymbol TYVAR),(TYVARleft,TYVARright))
460 :     :: tyvar_pc)
461 :    
462 :     db : db AND db (db1 @ db2)
463 :     | tyvars ident EQUALOP dbrhs ([Db{tyc=tycSymbol ident,
464 :     tyvars=tyvars,
465 : monnier 109 rhs=dbrhs,lazyp=false}])
466 :     | LAZY tyvars ident EQUALOP dbrhs
467 :     ([Db{tyc=tycSymbol ident,
468 : monnier 16 tyvars=tyvars,
469 : monnier 109 rhs=dbrhs,lazyp=true}])
470 : monnier 16
471 :     dbrhs : constrs (Constrs constrs)
472 :     | DATATYPE tycon (Repl tycon)
473 :    
474 :     constrs : constr ([constr])
475 :     | constr BAR constrs (constr :: constrs)
476 :    
477 :     constr : op_op ident (varSymbol ident, NONE)
478 :     | op_op ident OF ty (varSymbol ident, SOME ty)
479 :    
480 :     eb : op_op ident ([EbGen{exn=(varSymbol ident),etype=NONE}])
481 :     | op_op ident OF ty ([EbGen{exn=(varSymbol ident),etype=SOME ty}])
482 :     | op_op ident EQUALOP qid ([EbDef{exn=varSymbol ident,
483 :     edef=qid varSymbol}])
484 :     | eb AND eb (eb1 @ eb2)
485 :    
486 :     qid_p : qid ([qid strSymbol])
487 :     | qid qid_p (qid strSymbol :: qid_p)
488 :    
489 :     fixity : INFIX (infixleft 0)
490 :     | INFIX int (infixleft (checkFix(IntInf.toInt int,error(intleft,intright))))
491 :     | INFIXR (infixright 0)
492 :     | INFIXR int (infixright (checkFix(IntInf.toInt int,error(intleft,intright))))
493 :     | NONFIX (NONfix)
494 :    
495 :     ldec : VAL vb (ValDec(vb,nil))
496 :     | VAL tyvarseq vb (ValDec(vb,tyvarseq))
497 :     | VAL REC rvb (ValrecDec(rvb,nil))
498 :     | VAL REC tyvarseq rvb (ValrecDec(rvb,tyvarseq))
499 :     | FUN fb (FunDec(fb,nil))
500 :     | FUN tyvarseq fb (FunDec(fb,tyvarseq))
501 :     | TYPE tb (TypeDec tb)
502 :     | DATATYPE db (DatatypeDec{datatycs=db,withtycs=[]})
503 :     | DATATYPE db WITHTYPE tb (DatatypeDec{datatycs=db,withtycs=tb})
504 :     | ABSTYPE db WITH ldecs END (AbstypeDec{abstycs=db,withtycs=[],
505 :     body=ldecs})
506 :     | ABSTYPE db WITHTYPE tb WITH ldecs END (AbstypeDec{abstycs=db,
507 :     withtycs=tb,
508 :     body=ldecs})
509 :     | EXCEPTION eb (ExceptionDec eb)
510 :     | OPEN qid_p (OpenDec qid_p)
511 :     | fixity ops (FixDec{fixity=fixity, ops=ops})
512 :     | OVERLOAD ident COLON ty AS exp_pa
513 :     (OvldDec(varSymbol ident,ty,exp_pa))
514 :    
515 :     exp_pa : exp ([exp])
516 :     | exp AND exp_pa (exp :: exp_pa)
517 :    
518 :     ldecs : (SeqDec nil)
519 :     | ldec ldecs (makeSEQdec
520 :     (markdec(ldec,ldecleft,ldecright), ldecs))
521 :     | SEMICOLON ldecs (ldecs)
522 :     | LOCAL ldecs IN ldecs END ldecs
523 :     (makeSEQdec
524 :     (markdec(LocalDec(markdec(ldecs1,ldecs1left,ldecs1right),
525 :     markdec(ldecs2,ldecs2left,ldecs2right)),
526 :     LOCALleft,ENDright),
527 :     ldecs3))
528 :    
529 :     ops : ident ([fixSymbol ident])
530 :     | ident ops (fixSymbol ident :: ops)
531 :    
532 :     spec_s : ([])
533 :     | spec spec_s (spec @ spec_s)
534 :     | SEMICOLON spec_s (spec_s)
535 :    
536 :     spec : STRUCTURE strspec ([StrSpec strspec])
537 :     | FUNCTOR fctspec ([FctSpec fctspec])
538 :     | DATATYPE db ([DataSpec{datatycs=db,withtycs=nil}])
539 :     | DATATYPE db WITHTYPE tb ([DataSpec{datatycs=db,withtycs=tb}])
540 :     | TYPE tyspec ([TycSpec(tyspec,false)])
541 :     | EQTYPE tyspec ([TycSpec(tyspec,true)])
542 :     | VAL valspec ([ValSpec valspec])
543 :     | EXCEPTION exnspec ([ExceSpec exnspec])
544 :     | SHARING sharespec (sharespec)
545 :     | INCLUDE sign ([IncludeSpec sign])
546 :     | INCLUDE ident idents (IncludeSpec(VarSig(FastSymbol.sigSymbol ident))
547 :     :: idents)
548 :    
549 :     idents : ident ([IncludeSpec(VarSig(FastSymbol.sigSymbol ident))])
550 :     | ident idents (IncludeSpec(VarSig(FastSymbol.sigSymbol ident))
551 :     :: idents)
552 :    
553 :     strspec : strspec AND strspec (strspec1 @ strspec2)
554 :     | ident COLON sign ([(strSymbol ident, sign, NONE)])
555 :     | ident COLON sign EQUALOP qid
556 :     ([(strSymbol ident, sign, SOME(qid strSymbol))])
557 :    
558 :     fctspec : fctspec AND fctspec (fctspec1 @ fctspec2)
559 :     | ident fsig ([(fctSymbol ident, fsig)])
560 :    
561 :     tyspec : tyspec AND tyspec (tyspec1 @ tyspec2)
562 :     | tyvars ID ([(tycSymbol ID,tyvars,NONE)])
563 :     | tyvars ID EQUALOP ty ([(tycSymbol ID,tyvars,SOME ty)])
564 :    
565 :     valspec : valspec AND valspec (valspec1 @ valspec2)
566 :     | op_op ident COLON ty ([(varSymbol ident,ty)])
567 :    
568 :    
569 :     exnspec : exnspec AND exnspec (exnspec1 @ exnspec2)
570 :     | ident ([(varSymbol ident,NONE)])
571 :     | ident OF ty ([(varSymbol ident,SOME ty)])
572 :    
573 :     sharespec: sharespec AND sharespec (sharespec1 @ sharespec2)
574 :     | TYPE patheqn ([MarkSpec (ShareTycSpec(patheqn tycSymbol),
575 :     (patheqnleft,patheqnright))])
576 :     | patheqn ([MarkSpec (ShareStrSpec (patheqn strSymbol),
577 :     (patheqnleft,patheqnright))])
578 :    
579 :     patheqn : qid EQUALOP qid (fn kind => [qid1 kind, qid2 kind])
580 :     | qid EQUALOP patheqn (fn kind => qid kind :: patheqn kind)
581 :    
582 :     whspec : whspec AND whspec (whspec1 @ whspec2)
583 :     | TYPE tyvars qid EQUALOP ty
584 :     ([WhType(qid tycSymbol,tyvars,ty)])
585 :     | qid EQUALOP qid ([WhStruct(qid1 strSymbol,qid2 strSymbol)])
586 :    
587 :     sign : ident (MarkSig(VarSig (sigSymbol ident),
588 :     (identleft,identright)))
589 :     | SIG spec_s END (MarkSig(BaseSig(spec_s),(spec_sleft,spec_sright)))
590 :     | sign WHERE whspec (MarkSig(AugSig(sign,whspec),(signleft,whspecright)))
591 :    
592 :     sigconstraint_op : (NoSig)
593 :     | COLON sign (Transparent(sign))
594 :     | COLONGT sign (Opaque(sign))
595 :    
596 :     fsigconstraint_op : (NoSig)
597 :     | COLON ident (Transparent(VarFsig (fsigSymbol ident)))
598 :     | COLONGT ident (Opaque(VarFsig (fsigSymbol ident)))
599 :    
600 :     sigb : sigb AND sigb (sigb1 @ sigb2)
601 :     | ident EQUALOP sign ([Sigb{name=sigSymbol ident,def=sign}])
602 :    
603 :     fsigb : fsigb AND fsigb (fsigb1 @ fsigb2)
604 :     | ident fparamList EQUALOP sign
605 :     ([Fsigb{name=fsigSymbol ident,
606 :     def=BaseFsig{param=fparamList,result=sign}}])
607 :    
608 :     fsig : COLON ident (VarFsig (fsigSymbol ident))
609 :     | fparamList COLON sign
610 :     (BaseFsig{param=fparamList,result=sign})
611 :    
612 :     str : qid ((MarkStr(VarStr(qid strSymbol),(qidleft,qidright))))
613 :     | STRUCT strdecs END
614 :     (MarkStr(BaseStr strdecs,(STRUCTleft,ENDright)))
615 :     | qid arg_fct
616 :     (MarkStr(AppStr(qid fctSymbol,arg_fct),
617 :     (qidleft,arg_fctright)))
618 :     | LET strdecs IN str END
619 :     (MarkStr(LetStr(strdecs, str), (LETleft,ENDright)))
620 :     | str COLON sign
621 :     (MarkStr(ConstrainedStr(str,Transparent sign),
622 :     (strleft,signright)))
623 :     | str COLONGT sign
624 :     (MarkStr(ConstrainedStr(str,Opaque sign),
625 :     (strleft,signright)))
626 :    
627 :     arg_fct : LPAREN strdecs RPAREN arg_fct ((MarkStr(BaseStr strdecs,
628 :     (strdecsleft,strdecsright)),
629 :     false) :: arg_fct)
630 :     | LPAREN str RPAREN arg_fct ((str, true) :: arg_fct)
631 :     | LPAREN str RPAREN ([(str, true)])
632 :     | LPAREN strdecs RPAREN ([(MarkStr(BaseStr strdecs,
633 :     (strdecsleft,strdecsright)),
634 :     false)])
635 :    
636 :     strdecs : strdec strdecs (makeSEQdec (markdec(strdec,strdecleft,strdecright),
637 :     strdecs))
638 :     | SEMICOLON strdecs (strdecs)
639 :     | (SeqDec[])
640 :    
641 :     sdecs : sdec sdecs (makeSEQdec (markdec(sdec,sdecleft,sdecright),
642 :     sdecs))
643 :     | SEMICOLON sdecs (sdecs)
644 :     | (SeqDec[])
645 :    
646 :     sdecs' : sdec sdecs' (makeSEQdec (markdec(sdec,sdecleft,sdecright),
647 :     sdecs'))
648 :     | sdec (markdec(sdec, sdecleft,sdecright))
649 :    
650 :     strdec : STRUCTURE strb (StrDec strb)
651 :     | FUNCTOR fctb (FctDec fctb)
652 :     | LOCAL strdecs IN strdecs END (LocalDec(markdec(strdecs1,
653 :     strdecs1left,strdecs1right),
654 :     markdec(strdecs2,strdecs2left,strdecs2right)))
655 :     | ldec (markdec(ldec,ldecleft,ldecright))
656 :    
657 :     sdec : STRUCTURE strb (StrDec strb)
658 :     | SIGNATURE sigb (SigDec sigb)
659 :     | FUNSIG fsigb (FsigDec fsigb)
660 :     | FUNCTOR fctb (FctDec fctb)
661 :     | LOCAL sdecs IN sdecs END (LocalDec(markdec(sdecs1,
662 :     sdecs1left,sdecs1right),
663 :     markdec(sdecs2,sdecs2left,sdecs2right)))
664 :     | ldec (markdec(ldec,ldecleft,ldecright))
665 :    
666 :     strb : ident sigconstraint_op EQUALOP str
667 :     ([MarkStrb(Strb{name = strSymbol ident,def = str,
668 :     constraint=sigconstraint_op},
669 :     (identleft,strright))])
670 :     | strb AND strb (strb1 @ strb2)
671 :    
672 :     fparam : ID COLON sign ((SOME(strSymbol ID),sign))
673 :     | spec_s ((NONE,MarkSig(BaseSig(spec_s),
674 :     (spec_sleft,spec_sright))))
675 :    
676 :     fparamList
677 :     : LPAREN fparam RPAREN ([fparam])
678 :     | LPAREN fparam RPAREN fparamList (fparam :: fparamList)
679 :    
680 :     fctb : ident fparamList sigconstraint_op EQUALOP str
681 :     ([MarkFctb(Fctb {name = fctSymbol ident,
682 :     def = BaseFct{params=fparamList, body=str,
683 :     constraint=sigconstraint_op}},
684 :     (identleft,strright))])
685 :     | ident fsigconstraint_op EQUALOP fct_exp
686 :     ([MarkFctb(Fctb {name=fctSymbol ident,
687 :     def=fct_exp (fsigconstraint_op)},
688 :     (identleft,fct_expright))])
689 :     | fctb AND fctb (fctb1 @ fctb2)
690 :    
691 :     fct_exp: qid (fn constraint => VarFct(qid fctSymbol,constraint))
692 :     | qid arg_fct
693 :     (fn constraint =>
694 :     MarkFct(AppFct(qid fctSymbol,arg_fct,constraint),
695 :     (qidleft,arg_fctright)))
696 :     | LET strdecs IN fct_exp END
697 :     (fn constraint =>
698 :     MarkFct(LetFct(strdecs, fct_exp constraint),
699 :     (LETleft,ENDright)))
700 :    
701 :     interdec: sdecs' (markdec(sdecs',sdecs'left,sdecs'right))
702 :    
703 : monnier 109 | exp (markdec(ValDec([Vb{exp=exp,pat=VarPat itsym,lazyp=false}],nil),
704 : monnier 16 expleft,expright))

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