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 /ml-burg/releases/release-110.67/burg-lex.sml
ViewVC logotype

Annotation of /ml-burg/releases/release-110.67/burg-lex.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2687 - (view) (download)
Original Path: ml-burg/trunk/burg-lex.sml

1 : blume 2590 functor BurgLexFun(structure Tokens : Burg_TOKENS) = struct
2 :    
3 :     structure yyInput : sig
4 :    
5 :     type stream
6 :     val mkStream : (int -> string) -> stream
7 :     val fromStream : TextIO.StreamIO.instream -> stream
8 :     val getc : stream -> (Char.char * stream) option
9 :     val getpos : stream -> int
10 :     val getlineNo : stream -> int
11 :     val subtract : stream * stream -> string
12 :     val eof : stream -> bool
13 :    
14 :     end = struct
15 :    
16 :     structure TIO = TextIO
17 :     structure TSIO = TIO.StreamIO
18 :     structure TPIO = TextPrimIO
19 :    
20 :     datatype stream = Stream of {
21 :     strm : TSIO.instream,
22 :     id : int, (* track which streams originated
23 :     * from the same stream *)
24 :     pos : int,
25 :     lineNo : int
26 :     }
27 :    
28 :     local
29 :     val next = ref 0
30 :     in
31 :     fun nextId() = !next before (next := !next + 1)
32 :     end
33 :    
34 :     val initPos = 2 (* ml-lex bug compatibility *)
35 :    
36 :     fun mkStream inputN = let
37 :     val strm = TSIO.mkInstream
38 :     (TPIO.RD {
39 :     name = "lexgen",
40 :     chunkSize = 4096,
41 :     readVec = SOME inputN,
42 :     readArr = NONE,
43 :     readVecNB = NONE,
44 :     readArrNB = NONE,
45 :     block = NONE,
46 :     canInput = NONE,
47 :     avail = (fn () => NONE),
48 :     getPos = NONE,
49 :     setPos = NONE,
50 :     endPos = NONE,
51 :     verifyPos = NONE,
52 :     close = (fn () => ()),
53 :     ioDesc = NONE
54 :     }, "")
55 :     in
56 :     Stream {strm = strm, id = nextId(), pos = initPos, lineNo = 1}
57 :     end
58 :    
59 :     fun fromStream strm = Stream {
60 :     strm = strm, id = nextId(), pos = initPos, lineNo = 1
61 :     }
62 :    
63 :     fun getc (Stream {strm, pos, id, lineNo}) = (case TSIO.input1 strm
64 :     of NONE => NONE
65 :     | SOME (c, strm') =>
66 :     SOME (c, Stream {
67 :     strm = strm',
68 :     pos = pos+1,
69 :     id = id,
70 :     lineNo = lineNo +
71 :     (if c = #"\n" then 1 else 0)
72 :     })
73 :     (* end case*))
74 :    
75 :     fun getpos (Stream {pos, ...}) = pos
76 :    
77 :     fun getlineNo (Stream {lineNo, ...}) = lineNo
78 :    
79 :     fun subtract (new, old) = let
80 :     val Stream {strm = strm, pos = oldPos, id = oldId, ...} = old
81 :     val Stream {pos = newPos, id = newId, ...} = new
82 :     val (diff, _) = if newId = oldId andalso newPos >= oldPos
83 :     then TSIO.inputN (strm, newPos - oldPos)
84 :     else raise Fail
85 :     "BUG: yyInput: attempted to subtract incompatible streams"
86 :     in
87 :     diff
88 :     end
89 :    
90 :     fun eof (Stream {strm, ...}) = TSIO.endOfStream strm
91 :    
92 :     end
93 :    
94 :     datatype yystart_state =
95 :     DUMP | POSTLUDE | COMMENT | INITIAL
96 :     structure UserDeclarations =
97 : blume 2501 struct
98 : blume 2590
99 : blume 2501 (* burg-lex
100 :     *
101 :     * COPYRIGHT (c) 1995 AT&T Bell Laboratories.
102 :     *
103 :     * ML-Lex specification for ML-burg.
104 :     *)
105 :    
106 :     structure T = Tokens
107 :     structure E = ErrorMsg
108 :     type pos = int
109 :     type svalue = T.svalue
110 :     type ('a,'b) token = ('a,'b) T.token
111 :     type lexresult = (svalue,pos) token
112 :    
113 :     val comLevel = ref 0
114 :     val lineNum = ref 0
115 :     val verbatimLevel = ref 0
116 :     val percentCount = ref 0
117 :     val rawLine = ref ""
118 :     val rawNoNewLine = ref false
119 :     val raw:string list ref = ref []
120 :     val reachedEop = ref false
121 :    
122 :     fun resetState() = (comLevel := 0;
123 :     lineNum := 0;
124 :     verbatimLevel := 0;
125 :     percentCount := 0;
126 :     rawLine := "";
127 :     rawNoNewLine := false;
128 :     raw := [];
129 :     reachedEop := false)
130 :    
131 :     fun inc (ri as ref i) = (ri := i+1)
132 :     fun dec (ri as ref i) = (ri := i-1)
133 :    
134 :     fun incVerbLvl() = if !verbatimLevel <> 0
135 :     then E.impossible "nested verbatim levels"
136 :     else inc verbatimLevel
137 :    
138 :     fun outputRaw (s:string) = (rawLine := !rawLine^s; rawNoNewLine := true)
139 :    
140 :     fun rawNextLine () = (raw := !rawLine^"\n":: (!raw);
141 :     rawLine := ""; rawNoNewLine := false)
142 :    
143 :     fun rawStop () = if !rawNoNewLine then rawNextLine () else ()
144 :    
145 :     fun eof() = (if !comLevel > 0 then E.complain "unclosed comment"
146 :     else if !verbatimLevel <> 0 then
147 :     E.complain "unclosed user input"
148 :     else ();
149 :     if !reachedEop
150 :     then T.K_EOF(!lineNum,!lineNum)
151 :     else (rawStop ();
152 :     T.PPERCENT(rev(!raw),!lineNum,!lineNum)
153 :     before (raw := [];
154 :     reachedEop := true)))
155 :    
156 :    
157 :    
158 : blume 2590 end
159 : blume 2501
160 : blume 2590 datatype yymatch
161 :     = yyNO_MATCH
162 :     | yyMATCH of yyInput.stream * action * yymatch
163 :     withtype action = yyInput.stream * yymatch -> UserDeclarations.lexresult
164 : blume 2501
165 : blume 2590 local
166 : blume 2501
167 : blume 2590 val yytable =
168 :     #[
169 :     ]
170 : blume 2501
171 : blume 2590 fun mk yyins = let
172 :     (* current start state *)
173 : blume 2630 val yyss = ref INITIAL
174 :     fun YYBEGIN ss = (yyss := ss)
175 : blume 2590 (* current input stream *)
176 : blume 2630 val yystrm = ref yyins
177 : blume 2590 (* get one char of input *)
178 : blume 2687 val yylastwasnref = ref true
179 :     fun yygetc strm = (case yyInput.getc strm
180 :     of NONE => NONE
181 :     | SOME (#"\n", strm') => (yylastwasnref := true; SOME (#"\n", strm'))
182 :     | SOME (c, strm') => (yylastwasnref := false; SOME (c, strm'))
183 :     (* end case *))
184 : blume 2590 (* create yytext *)
185 : blume 2630 fun yymktext(strm) = yyInput.subtract (strm, !yystrm)
186 :     open UserDeclarations
187 :     fun lex
188 :     (yyarg as ()) = let
189 :     fun continue() = let
190 : blume 2687 val yylastwasn = !yylastwasnref
191 : blume 2590 fun yystuck (yyNO_MATCH) = raise Fail "stuck state"
192 :     | yystuck (yyMATCH (strm, action, old)) =
193 :     action (strm, old)
194 :     val yypos = yyInput.getpos (!yystrm)
195 :     val yygetlineNo = yyInput.getlineNo
196 :     fun yyactsToMatches (strm, [], oldMatches) = oldMatches
197 :     | yyactsToMatches (strm, act::acts, oldMatches) =
198 :     yyMATCH (strm, act, yyactsToMatches (strm, acts, oldMatches))
199 :     fun yygo actTable =
200 :     (fn (~1, _, oldMatches) => yystuck oldMatches
201 :     | (curState, strm, oldMatches) => let
202 :     val (transitions, finals') = Vector.sub (yytable, curState)
203 :     val finals = map (fn i => Vector.sub (actTable, i)) finals'
204 :     fun tryfinal() =
205 :     yystuck (yyactsToMatches (strm, finals, oldMatches))
206 :     fun find (c, []) = NONE
207 :     | find (c, (c1, c2, s)::ts) =
208 :     if c1 <= c andalso c <= c2 then SOME s
209 :     else find (c, ts)
210 :     in case yygetc strm
211 :     of SOME(c, strm') =>
212 :     (case find (c, transitions)
213 :     of NONE => tryfinal()
214 :     | SOME n =>
215 :     yygo actTable
216 :     (n, strm',
217 :     yyactsToMatches (strm, finals, oldMatches)))
218 :     | NONE => tryfinal()
219 :     end)
220 : blume 2630 in
221 : blume 2590 let
222 :     fun yyAction0 (strm, lastMatch : yymatch) = (yystrm := strm;
223 :     (inc lineNum; continue()))
224 :     fun yyAction1 (strm, lastMatch : yymatch) = (yystrm := strm;
225 :     (incVerbLvl(); YYBEGIN DUMP; continue()))
226 :     fun yyAction2 (strm, lastMatch : yymatch) = (yystrm := strm;
227 :     (inc percentCount;
228 : blume 2501 if !percentCount = 2
229 :     then (YYBEGIN POSTLUDE; continue())
230 :     else T.PPERCENT(rev(!raw),!lineNum,!lineNum)
231 : blume 2590 before raw := []))
232 :     fun yyAction3 (strm, lastMatch : yymatch) = (yystrm := strm; (continue()))
233 :     fun yyAction4 (strm, lastMatch : yymatch) = (yystrm := strm;
234 :     (inc lineNum; continue()))
235 :     fun yyAction5 (strm, lastMatch : yymatch) = (yystrm := strm;
236 :     (T.K_LPAREN(!lineNum,!lineNum)))
237 :     fun yyAction6 (strm, lastMatch : yymatch) = (yystrm := strm;
238 :     (T.K_RPAREN(!lineNum,!lineNum)))
239 :     fun yyAction7 (strm, lastMatch : yymatch) = (yystrm := strm;
240 :     (T.K_COMMA(!lineNum,!lineNum)))
241 :     fun yyAction8 (strm, lastMatch : yymatch) = (yystrm := strm;
242 :     (T.K_COLON(!lineNum,!lineNum)))
243 :     fun yyAction9 (strm, lastMatch : yymatch) = (yystrm := strm;
244 :     (T.K_SEMICOLON(!lineNum,!lineNum)))
245 :     fun yyAction10 (strm, lastMatch : yymatch) = (yystrm := strm;
246 :     (T.K_EQUAL(!lineNum,!lineNum)))
247 :     fun yyAction11 (strm, lastMatch : yymatch) = (yystrm := strm;
248 :     (T.K_PIPE(!lineNum,!lineNum)))
249 :     fun yyAction12 (strm, lastMatch : yymatch) = (yystrm := strm;
250 :     (T.K_TERM(!lineNum,!lineNum)))
251 :     fun yyAction13 (strm, lastMatch : yymatch) = (yystrm := strm;
252 :     (T.K_START(!lineNum,!lineNum)))
253 :     fun yyAction14 (strm, lastMatch : yymatch) = (yystrm := strm;
254 :     (T.K_TERMPREFIX(!lineNum,!lineNum)))
255 :     fun yyAction15 (strm, lastMatch : yymatch) = (yystrm := strm;
256 :     (T.K_RULEPREFIX(!lineNum,!lineNum)))
257 :     fun yyAction16 (strm, lastMatch : yymatch) = (yystrm := strm;
258 :     (T.K_SIG(!lineNum,!lineNum)))
259 :     fun yyAction17 (strm, lastMatch : yymatch) = (yystrm := strm;
260 :     (YYBEGIN COMMENT; comLevel:=1; continue()))
261 :     fun yyAction18 (strm, lastMatch : yymatch) = let
262 :     val yytext = yymktext(strm)
263 :     in
264 :     yystrm := strm; (T.INT(valOf(Int.fromString yytext),!lineNum,!lineNum))
265 :     end
266 :     fun yyAction19 (strm, lastMatch : yymatch) = let
267 :     val yytext = yymktext(strm)
268 :     in
269 :     yystrm := strm; (T.ID(yytext,!lineNum,!lineNum))
270 :     end
271 :     fun yyAction20 (strm, lastMatch : yymatch) = (yystrm := strm;
272 :     (inc comLevel; continue()))
273 :     fun yyAction21 (strm, lastMatch : yymatch) = (yystrm := strm;
274 :     (inc lineNum; continue()))
275 :     fun yyAction22 (strm, lastMatch : yymatch) = (yystrm := strm;
276 :     (dec comLevel;
277 : blume 2501 if !comLevel=0 then YYBEGIN INITIAL else ();
278 : blume 2590 continue()))
279 :     fun yyAction23 (strm, lastMatch : yymatch) = (yystrm := strm; (continue()))
280 :     fun yyAction24 (strm, lastMatch : yymatch) = (yystrm := strm;
281 :     (rawStop(); dec verbatimLevel;
282 :     YYBEGIN INITIAL; continue()))
283 :     fun yyAction25 (strm, lastMatch : yymatch) = (yystrm := strm;
284 :     (rawNextLine (); inc lineNum; continue()))
285 :     fun yyAction26 (strm, lastMatch : yymatch) = let
286 :     val yytext = yymktext(strm)
287 :     in
288 :     yystrm := strm; (outputRaw yytext; continue())
289 :     end
290 :     fun yyAction27 (strm, lastMatch : yymatch) = (yystrm := strm;
291 :     (rawNextLine (); inc lineNum; continue()))
292 :     fun yyAction28 (strm, lastMatch : yymatch) = let
293 :     val yytext = yymktext(strm)
294 :     in
295 :     yystrm := strm; (outputRaw yytext; continue())
296 :     end
297 :     fun yyQ27 (strm, lastMatch : yymatch) = yyAction11(strm, yyNO_MATCH)
298 :     fun yyQ26 (strm, lastMatch : yymatch) = (case (yygetc(strm))
299 :     of NONE => yyAction19(strm, yyNO_MATCH)
300 :     | SOME(inp, strm') =>
301 :     if inp = #"["
302 :     then yyAction19(strm, yyNO_MATCH)
303 :     else if inp < #"["
304 :     then if inp = #":"
305 :     then yyAction19(strm, yyNO_MATCH)
306 :     else if inp < #":"
307 :     then if inp <= #"/"
308 :     then yyAction19(strm, yyNO_MATCH)
309 :     else yyQ26(strm', yyMATCH(strm, yyAction19, yyNO_MATCH))
310 :     else if inp <= #"@"
311 :     then yyAction19(strm, yyNO_MATCH)
312 :     else yyQ26(strm', yyMATCH(strm, yyAction19, yyNO_MATCH))
313 :     else if inp = #"`"
314 :     then yyAction19(strm, yyNO_MATCH)
315 :     else if inp < #"`"
316 :     then if inp = #"_"
317 :     then yyQ26(strm', yyMATCH(strm, yyAction19, yyNO_MATCH))
318 :     else yyAction19(strm, yyNO_MATCH)
319 :     else if inp <= #"z"
320 :     then yyQ26(strm', yyMATCH(strm, yyAction19, yyNO_MATCH))
321 :     else yyAction19(strm, yyNO_MATCH)
322 :     (* end case *))
323 :     fun yyQ25 (strm, lastMatch : yymatch) = yyAction10(strm, yyNO_MATCH)
324 :     fun yyQ24 (strm, lastMatch : yymatch) = yyAction9(strm, yyNO_MATCH)
325 :     fun yyQ23 (strm, lastMatch : yymatch) = yyAction8(strm, yyNO_MATCH)
326 :     fun yyQ22 (strm, lastMatch : yymatch) = (case (yygetc(strm))
327 :     of NONE => yyAction18(strm, yyNO_MATCH)
328 :     | SOME(inp, strm') =>
329 :     if inp = #"0"
330 :     then yyQ22(strm', yyMATCH(strm, yyAction18, yyNO_MATCH))
331 :     else if inp < #"0"
332 :     then yyAction18(strm, yyNO_MATCH)
333 :     else if inp <= #"9"
334 :     then yyQ22(strm', yyMATCH(strm, yyAction18, yyNO_MATCH))
335 :     else yyAction18(strm, yyNO_MATCH)
336 :     (* end case *))
337 :     fun yyQ21 (strm, lastMatch : yymatch) = yyAction7(strm, yyNO_MATCH)
338 :     fun yyQ20 (strm, lastMatch : yymatch) = yyAction6(strm, yyNO_MATCH)
339 :     fun yyQ28 (strm, lastMatch : yymatch) = yyAction17(strm, yyNO_MATCH)
340 :     fun yyQ19 (strm, lastMatch : yymatch) = (case (yygetc(strm))
341 :     of NONE => yyAction5(strm, yyNO_MATCH)
342 :     | SOME(inp, strm') =>
343 :     if inp = #"*"
344 :     then yyQ28(strm', yyMATCH(strm, yyAction5, yyNO_MATCH))
345 :     else yyAction5(strm, yyNO_MATCH)
346 :     (* end case *))
347 :     fun yyQ33 (strm, lastMatch : yymatch) = yyAction1(strm, yyNO_MATCH)
348 :     fun yyQ42 (strm, lastMatch : yymatch) = yyAction14(strm, yyNO_MATCH)
349 :     fun yyQ41 (strm, lastMatch : yymatch) = (case (yygetc(strm))
350 :     of NONE => yystuck(lastMatch)
351 :     | SOME(inp, strm') =>
352 :     if inp = #"x"
353 :     then yyQ42(strm', lastMatch)
354 :     else yystuck(lastMatch)
355 :     (* end case *))
356 :     fun yyQ40 (strm, lastMatch : yymatch) = (case (yygetc(strm))
357 :     of NONE => yystuck(lastMatch)
358 :     | SOME(inp, strm') =>
359 :     if inp = #"i"
360 :     then yyQ41(strm', lastMatch)
361 :     else yystuck(lastMatch)
362 :     (* end case *))
363 :     fun yyQ39 (strm, lastMatch : yymatch) = (case (yygetc(strm))
364 :     of NONE => yystuck(lastMatch)
365 :     | SOME(inp, strm') =>
366 :     if inp = #"f"
367 :     then yyQ40(strm', lastMatch)
368 :     else yystuck(lastMatch)
369 :     (* end case *))
370 :     fun yyQ38 (strm, lastMatch : yymatch) = (case (yygetc(strm))
371 :     of NONE => yystuck(lastMatch)
372 :     | SOME(inp, strm') =>
373 :     if inp = #"e"
374 :     then yyQ39(strm', lastMatch)
375 :     else yystuck(lastMatch)
376 :     (* end case *))
377 :     fun yyQ37 (strm, lastMatch : yymatch) = (case (yygetc(strm))
378 :     of NONE => yystuck(lastMatch)
379 :     | SOME(inp, strm') =>
380 :     if inp = #"r"
381 :     then yyQ38(strm', lastMatch)
382 :     else yystuck(lastMatch)
383 :     (* end case *))
384 :     fun yyQ36 (strm, lastMatch : yymatch) = (case (yygetc(strm))
385 :     of NONE => yyAction12(strm, yyNO_MATCH)
386 :     | SOME(inp, strm') =>
387 :     if inp = #"p"
388 :     then yyQ37(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
389 :     else yyAction12(strm, yyNO_MATCH)
390 :     (* end case *))
391 :     fun yyQ35 (strm, lastMatch : yymatch) = (case (yygetc(strm))
392 :     of NONE => yystuck(lastMatch)
393 :     | SOME(inp, strm') =>
394 :     if inp = #"m"
395 :     then yyQ36(strm', lastMatch)
396 :     else yystuck(lastMatch)
397 :     (* end case *))
398 :     fun yyQ34 (strm, lastMatch : yymatch) = (case (yygetc(strm))
399 :     of NONE => yystuck(lastMatch)
400 :     | SOME(inp, strm') =>
401 :     if inp = #"r"
402 :     then yyQ35(strm', lastMatch)
403 :     else yystuck(lastMatch)
404 :     (* end case *))
405 :     fun yyQ32 (strm, lastMatch : yymatch) = (case (yygetc(strm))
406 :     of NONE => yystuck(lastMatch)
407 :     | SOME(inp, strm') =>
408 :     if inp = #"e"
409 :     then yyQ34(strm', lastMatch)
410 :     else yystuck(lastMatch)
411 :     (* end case *))
412 :     fun yyQ47 (strm, lastMatch : yymatch) = yyAction13(strm, yyNO_MATCH)
413 :     fun yyQ46 (strm, lastMatch : yymatch) = (case (yygetc(strm))
414 :     of NONE => yystuck(lastMatch)
415 :     | SOME(inp, strm') =>
416 :     if inp = #"t"
417 :     then yyQ47(strm', lastMatch)
418 :     else yystuck(lastMatch)
419 :     (* end case *))
420 :     fun yyQ45 (strm, lastMatch : yymatch) = (case (yygetc(strm))
421 :     of NONE => yystuck(lastMatch)
422 :     | SOME(inp, strm') =>
423 :     if inp = #"r"
424 :     then yyQ46(strm', lastMatch)
425 :     else yystuck(lastMatch)
426 :     (* end case *))
427 :     fun yyQ44 (strm, lastMatch : yymatch) = (case (yygetc(strm))
428 :     of NONE => yystuck(lastMatch)
429 :     | SOME(inp, strm') =>
430 :     if inp = #"a"
431 :     then yyQ45(strm', lastMatch)
432 :     else yystuck(lastMatch)
433 :     (* end case *))
434 :     fun yyQ48 (strm, lastMatch : yymatch) = yyAction16(strm, yyNO_MATCH)
435 :     fun yyQ43 (strm, lastMatch : yymatch) = (case (yygetc(strm))
436 :     of NONE => yystuck(lastMatch)
437 :     | SOME(inp, strm') =>
438 :     if inp = #"g"
439 :     then yyQ48(strm', lastMatch)
440 :     else yystuck(lastMatch)
441 :     (* end case *))
442 :     fun yyQ31 (strm, lastMatch : yymatch) = (case (yygetc(strm))
443 :     of NONE => yystuck(lastMatch)
444 :     | SOME(inp, strm') =>
445 :     if inp = #"j"
446 :     then yystuck(lastMatch)
447 :     else if inp < #"j"
448 :     then if inp = #"i"
449 :     then yyQ43(strm', lastMatch)
450 :     else yystuck(lastMatch)
451 :     else if inp = #"t"
452 :     then yyQ44(strm', lastMatch)
453 :     else yystuck(lastMatch)
454 :     (* end case *))
455 :     fun yyQ57 (strm, lastMatch : yymatch) = yyAction15(strm, yyNO_MATCH)
456 :     fun yyQ56 (strm, lastMatch : yymatch) = (case (yygetc(strm))
457 :     of NONE => yystuck(lastMatch)
458 :     | SOME(inp, strm') =>
459 :     if inp = #"x"
460 :     then yyQ57(strm', lastMatch)
461 :     else yystuck(lastMatch)
462 :     (* end case *))
463 :     fun yyQ55 (strm, lastMatch : yymatch) = (case (yygetc(strm))
464 :     of NONE => yystuck(lastMatch)
465 :     | SOME(inp, strm') =>
466 :     if inp = #"i"
467 :     then yyQ56(strm', lastMatch)
468 :     else yystuck(lastMatch)
469 :     (* end case *))
470 :     fun yyQ54 (strm, lastMatch : yymatch) = (case (yygetc(strm))
471 :     of NONE => yystuck(lastMatch)
472 :     | SOME(inp, strm') =>
473 :     if inp = #"f"
474 :     then yyQ55(strm', lastMatch)
475 :     else yystuck(lastMatch)
476 :     (* end case *))
477 :     fun yyQ53 (strm, lastMatch : yymatch) = (case (yygetc(strm))
478 :     of NONE => yystuck(lastMatch)
479 :     | SOME(inp, strm') =>
480 :     if inp = #"e"
481 :     then yyQ54(strm', lastMatch)
482 :     else yystuck(lastMatch)
483 :     (* end case *))
484 :     fun yyQ52 (strm, lastMatch : yymatch) = (case (yygetc(strm))
485 :     of NONE => yystuck(lastMatch)
486 :     | SOME(inp, strm') =>
487 :     if inp = #"r"
488 :     then yyQ53(strm', lastMatch)
489 :     else yystuck(lastMatch)
490 :     (* end case *))
491 :     fun yyQ51 (strm, lastMatch : yymatch) = (case (yygetc(strm))
492 :     of NONE => yystuck(lastMatch)
493 :     | SOME(inp, strm') =>
494 :     if inp = #"p"
495 :     then yyQ52(strm', lastMatch)
496 :     else yystuck(lastMatch)
497 :     (* end case *))
498 :     fun yyQ50 (strm, lastMatch : yymatch) = (case (yygetc(strm))
499 :     of NONE => yystuck(lastMatch)
500 :     | SOME(inp, strm') =>
501 :     if inp = #"e"
502 :     then yyQ51(strm', lastMatch)
503 :     else yystuck(lastMatch)
504 :     (* end case *))
505 :     fun yyQ49 (strm, lastMatch : yymatch) = (case (yygetc(strm))
506 :     of NONE => yystuck(lastMatch)
507 :     | SOME(inp, strm') =>
508 :     if inp = #"l"
509 :     then yyQ50(strm', lastMatch)
510 :     else yystuck(lastMatch)
511 :     (* end case *))
512 :     fun yyQ30 (strm, lastMatch : yymatch) = (case (yygetc(strm))
513 :     of NONE => yystuck(lastMatch)
514 :     | SOME(inp, strm') =>
515 :     if inp = #"u"
516 :     then yyQ49(strm', lastMatch)
517 :     else yystuck(lastMatch)
518 :     (* end case *))
519 :     fun yyQ29 (strm, lastMatch : yymatch) = yyAction2(strm, yyNO_MATCH)
520 :     fun yyQ18 (strm, lastMatch : yymatch) = (case (yygetc(strm))
521 :     of NONE => yystuck(lastMatch)
522 :     | SOME(inp, strm') =>
523 :     if inp = #"s"
524 :     then yyQ31(strm', lastMatch)
525 :     else if inp < #"s"
526 :     then if inp = #"&"
527 :     then yystuck(lastMatch)
528 :     else if inp < #"&"
529 :     then if inp = #"%"
530 :     then yyQ29(strm', lastMatch)
531 :     else yystuck(lastMatch)
532 :     else if inp = #"r"
533 :     then yyQ30(strm', lastMatch)
534 :     else yystuck(lastMatch)
535 :     else if inp = #"{"
536 :     then yyQ33(strm', lastMatch)
537 :     else if inp < #"{"
538 :     then if inp = #"t"
539 :     then yyQ32(strm', lastMatch)
540 :     else yystuck(lastMatch)
541 :     else yystuck(lastMatch)
542 :     (* end case *))
543 :     fun yyQ17 (strm, lastMatch : yymatch) = yyAction0(strm, yyNO_MATCH)
544 :     fun yyQ16 (strm, lastMatch : yymatch) = (case (yygetc(strm))
545 :     of NONE => yyAction3(strm, yyNO_MATCH)
546 :     | SOME(inp, strm') =>
547 :     if inp = #"\n"
548 :     then yyAction3(strm, yyNO_MATCH)
549 :     else if inp < #"\n"
550 :     then if inp = #"\t"
551 :     then yyQ16(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
552 :     else yyAction3(strm, yyNO_MATCH)
553 :     else if inp = #" "
554 :     then yyQ16(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
555 :     else yyAction3(strm, yyNO_MATCH)
556 :     (* end case *))
557 :     fun yyQ3 (strm, lastMatch : yymatch) = (case (yygetc(strm))
558 :     of NONE =>
559 :     if yyInput.eof(strm)
560 :     then UserDeclarations.eof(yyarg)
561 :     else yyAction3(strm, yyNO_MATCH)
562 :     | SOME(inp, strm') =>
563 :     if inp = #"-"
564 :     then if yyInput.eof(strm)
565 :     then UserDeclarations.eof(yyarg)
566 :     else yyAction3(strm, yyNO_MATCH)
567 :     else if inp < #"-"
568 :     then if inp = #"%"
569 :     then yyQ18(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
570 :     else if inp < #"%"
571 :     then if inp = #"\v"
572 :     then if yyInput.eof(strm)
573 :     then UserDeclarations.eof(yyarg)
574 :     else yyAction3(strm, yyNO_MATCH)
575 :     else if inp < #"\v"
576 :     then if inp = #"\t"
577 :     then yyQ16(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
578 :     else if inp = #"\n"
579 :     then yyQ17(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
580 :     else if yyInput.eof(strm)
581 :     then UserDeclarations.eof(yyarg)
582 :     else yyAction3(strm, yyNO_MATCH)
583 :     else if inp = #" "
584 :     then yyQ16(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
585 :     else if yyInput.eof(strm)
586 :     then UserDeclarations.eof(yyarg)
587 :     else yyAction3(strm, yyNO_MATCH)
588 :     else if inp = #")"
589 :     then yyQ20(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
590 :     else if inp < #")"
591 :     then if inp = #"("
592 :     then yyQ19(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
593 :     else if yyInput.eof(strm)
594 :     then UserDeclarations.eof(yyarg)
595 :     else yyAction3(strm, yyNO_MATCH)
596 :     else if inp = #","
597 :     then yyQ21(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
598 :     else if yyInput.eof(strm)
599 :     then UserDeclarations.eof(yyarg)
600 :     else yyAction3(strm, yyNO_MATCH)
601 :     else if inp = #">"
602 :     then if yyInput.eof(strm)
603 :     then UserDeclarations.eof(yyarg)
604 :     else yyAction3(strm, yyNO_MATCH)
605 :     else if inp < #">"
606 :     then if inp = #";"
607 :     then yyQ24(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
608 :     else if inp < #";"
609 :     then if inp = #"0"
610 :     then yyQ22(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
611 :     else if inp < #"0"
612 :     then if yyInput.eof(strm)
613 :     then UserDeclarations.eof(yyarg)
614 :     else yyAction3(strm, yyNO_MATCH)
615 :     else if inp = #":"
616 :     then yyQ23(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
617 :     else yyQ22(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
618 :     else if inp = #"<"
619 :     then if yyInput.eof(strm)
620 :     then UserDeclarations.eof(yyarg)
621 :     else yyAction3(strm, yyNO_MATCH)
622 :     else yyQ25(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
623 :     else if inp = #"a"
624 :     then yyQ26(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
625 :     else if inp < #"a"
626 :     then if inp = #"A"
627 :     then yyQ26(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
628 :     else if inp < #"A"
629 :     then if yyInput.eof(strm)
630 :     then UserDeclarations.eof(yyarg)
631 :     else yyAction3(strm, yyNO_MATCH)
632 :     else if inp <= #"Z"
633 :     then yyQ26(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
634 :     else if yyInput.eof(strm)
635 :     then UserDeclarations.eof(yyarg)
636 :     else yyAction3(strm, yyNO_MATCH)
637 :     else if inp = #"|"
638 :     then yyQ27(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
639 :     else if inp < #"|"
640 :     then if inp = #"{"
641 :     then if yyInput.eof(strm)
642 :     then UserDeclarations.eof(yyarg)
643 :     else yyAction3(strm, yyNO_MATCH)
644 :     else yyQ26(strm', yyMATCH(strm, yyAction3, yyNO_MATCH))
645 :     else if yyInput.eof(strm)
646 :     then UserDeclarations.eof(yyarg)
647 :     else yyAction3(strm, yyNO_MATCH)
648 :     (* end case *))
649 :     fun yyQ14 (strm, lastMatch : yymatch) = yyAction22(strm, yyNO_MATCH)
650 :     fun yyQ13 (strm, lastMatch : yymatch) = (case (yygetc(strm))
651 :     of NONE => yyAction23(strm, yyNO_MATCH)
652 :     | SOME(inp, strm') =>
653 :     if inp = #")"
654 :     then yyQ14(strm', yyMATCH(strm, yyAction23, yyNO_MATCH))
655 :     else yyAction23(strm, yyNO_MATCH)
656 :     (* end case *))
657 :     fun yyQ15 (strm, lastMatch : yymatch) = yyAction20(strm, yyNO_MATCH)
658 :     fun yyQ12 (strm, lastMatch : yymatch) = (case (yygetc(strm))
659 :     of NONE => yyAction23(strm, yyNO_MATCH)
660 :     | SOME(inp, strm') =>
661 :     if inp = #"*"
662 :     then yyQ15(strm', yyMATCH(strm, yyAction23, yyNO_MATCH))
663 :     else yyAction23(strm, yyNO_MATCH)
664 :     (* end case *))
665 :     fun yyQ11 (strm, lastMatch : yymatch) = yyAction21(strm, yyNO_MATCH)
666 :     fun yyQ10 (strm, lastMatch : yymatch) = yyAction23(strm, yyNO_MATCH)
667 :     fun yyQ2 (strm, lastMatch : yymatch) = (case (yygetc(strm))
668 :     of NONE =>
669 :     if yyInput.eof(strm)
670 :     then UserDeclarations.eof(yyarg)
671 :     else yystuck(lastMatch)
672 :     | SOME(inp, strm') =>
673 :     if inp = #"("
674 :     then yyQ12(strm', lastMatch)
675 :     else if inp < #"("
676 :     then if inp = #"\n"
677 :     then yyQ11(strm', lastMatch)
678 :     else yyQ10(strm', lastMatch)
679 :     else if inp = #"*"
680 :     then yyQ13(strm', lastMatch)
681 :     else yyQ10(strm', lastMatch)
682 :     (* end case *))
683 :     fun yyQ9 (strm, lastMatch : yymatch) = yyAction27(strm, yyNO_MATCH)
684 :     fun yyQ8 (strm, lastMatch : yymatch) = (case (yygetc(strm))
685 :     of NONE => yyAction28(strm, yyNO_MATCH)
686 :     | SOME(inp, strm') =>
687 :     if inp = #"\n"
688 :     then yyAction28(strm, yyNO_MATCH)
689 :     else yyQ8(strm', yyMATCH(strm, yyAction28, yyNO_MATCH))
690 :     (* end case *))
691 :     fun yyQ1 (strm, lastMatch : yymatch) = (case (yygetc(strm))
692 :     of NONE =>
693 :     if yyInput.eof(strm)
694 :     then UserDeclarations.eof(yyarg)
695 :     else yyAction28(strm, yyNO_MATCH)
696 :     | SOME(inp, strm') =>
697 :     if inp = #"\n"
698 :     then yyQ9(strm', yyMATCH(strm, yyAction28, yyNO_MATCH))
699 :     else yyQ8(strm', yyMATCH(strm, yyAction28, yyNO_MATCH))
700 :     (* end case *))
701 :     fun yyQ4 (strm, lastMatch : yymatch) = (case (yygetc(strm))
702 :     of NONE => yyAction26(strm, yyNO_MATCH)
703 :     | SOME(inp, strm') =>
704 :     if inp = #"\n"
705 :     then yyAction26(strm, yyNO_MATCH)
706 :     else yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
707 :     (* end case *))
708 :     fun yyQ7 (strm, lastMatch : yymatch) = (case (yygetc(strm))
709 :     of NONE => yyAction24(strm, yyNO_MATCH)
710 :     | SOME(inp, strm') =>
711 :     if inp = #"\n"
712 :     then yyAction24(strm, yyNO_MATCH)
713 :     else yyQ4(strm', yyMATCH(strm, yyAction24, yyNO_MATCH))
714 :     (* end case *))
715 :     fun yyQ6 (strm, lastMatch : yymatch) = (case (yygetc(strm))
716 :     of NONE => yyAction26(strm, yyNO_MATCH)
717 :     | SOME(inp, strm') =>
718 :     if inp = #"\v"
719 :     then yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
720 :     else if inp < #"\v"
721 :     then if inp = #"\n"
722 :     then yyAction26(strm, yyNO_MATCH)
723 :     else yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
724 :     else if inp = #"}"
725 :     then yyQ7(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
726 :     else yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
727 :     (* end case *))
728 :     fun yyQ5 (strm, lastMatch : yymatch) = yyAction25(strm, yyNO_MATCH)
729 :     fun yyQ0 (strm, lastMatch : yymatch) = (case (yygetc(strm))
730 :     of NONE =>
731 :     if yyInput.eof(strm)
732 :     then UserDeclarations.eof(yyarg)
733 :     else yyAction26(strm, yyNO_MATCH)
734 :     | SOME(inp, strm') =>
735 :     if inp = #"\v"
736 :     then yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
737 :     else if inp < #"\v"
738 :     then if inp = #"\n"
739 :     then yyQ5(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
740 :     else yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
741 :     else if inp = #"%"
742 :     then yyQ6(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
743 :     else yyQ4(strm', yyMATCH(strm, yyAction26, yyNO_MATCH))
744 :     (* end case *))
745 :     in
746 :     (case (!(yyss))
747 :     of DUMP => yyQ0(!(yystrm), yyNO_MATCH)
748 :     | POSTLUDE => yyQ1(!(yystrm), yyNO_MATCH)
749 :     | COMMENT => yyQ2(!(yystrm), yyNO_MATCH)
750 :     | INITIAL => yyQ3(!(yystrm), yyNO_MATCH)
751 :     (* end case *))
752 :     end
753 : blume 2630 end
754 : blume 2635 in
755 :     continue()
756 :     handle IO.Io{cause, ...} => raise cause
757 :     end
758 : blume 2630 in
759 :     lex
760 :     end
761 : blume 2590 in
762 :     fun makeLexer yyinputN = mk (yyInput.mkStream yyinputN)
763 :     fun makeLexer' ins = mk (yyInput.mkStream ins)
764 :     end
765 : blume 2501
766 :     end

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