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

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