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/lexgen/src/FrontEnds/ml-lex/ml-lex.lex.sml
ViewVC logotype

Annotation of /sml/trunk/src/lexgen/src/FrontEnds/ml-lex/ml-lex.lex.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1912 - (view) (download)

1 : mblume 1902 functor MLLexLexFun(structure Tok: MLLex_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 : mblume 1912 val initPos = 2 (* ml-lex bug compatibility *)
35 :    
36 : mblume 1902 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 : mblume 1912 Stream {strm = strm, id = nextId(), pos = initPos, lineNo = 1}
57 : mblume 1902 end
58 :    
59 :     fun fromStream strm = Stream {
60 : mblume 1912 strm = strm, id = nextId(), pos = initPos, lineNo = 1
61 : mblume 1902 }
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 'a yymatch
95 :     = yyNO_MATCH
96 :     | yyMATCH of yyInput.stream * 'a action * 'a yymatch
97 :     withtype 'a action = yyInput.stream * 'a yymatch -> 'a
98 :    
99 :     datatype yystart_state =
100 :     RE | DEFS | RECB | STRING | CHARCLASS | LEXSTATES | ACTION | INITIAL
101 :     structure UserDeclarations =
102 :     struct
103 :    
104 :     type pos = int
105 :     type svalue = Tok.svalue
106 :     type ('a,'b) token = ('a,'b) Tok.token
107 :     type lexresult= (svalue,pos) token
108 :    
109 :     open Tok
110 :    
111 :     val eof = fn () => EOF(~1,~1)
112 :     val error = (* fn (e,l : int,_) =>
113 :     output(std_out,"line " ^ (makestring l) ^
114 :     ": " ^ e ^ "\n") *)
115 :     fn _ => ()
116 :    
117 :     local
118 :     val text = ref ([] : string list)
119 :     in
120 :     fun clrAction () = (text := ["("])
121 :     fun updAction (str) = (text := str :: (!text))
122 :     fun getAction () = (concat (rev (!text)))
123 :     end
124 :    
125 :     (* what to do (i.e. switch start states) after recognizing an action *)
126 :     val afterAction = ref (fn () => ())
127 :    
128 :     (* paren counting for actions *)
129 :     val pcount = ref 0
130 :     val inquote = ref false
131 :     fun inc r = if !inquote then () else r := !r + 1
132 :     fun dec r = if !inquote then () else r := !r - 1
133 :    
134 :     structure SIS = RegExp.SymSet
135 :     fun uniChar s = let
136 :     fun toW32 (c : Char.char) : Word32.word =
137 :     (case c of #"0" => 0w0 | #"1" => 0w1 | #"2" => 0w2 | #"3" => 0w3
138 :     | #"4" => 0w4 | #"5" => 0w5 | #"6" => 0w6 | #"7" => 0w7
139 :     | #"8" => 0w8 | #"9" => 0w9 | #"a" => 0w10 | #"A" => 0w10
140 :     | #"b" => 0w11 | #"B" => 0w11 | #"c" => 0w12 | #"C" => 0w12
141 :     | #"d" => 0w13 | #"D" => 0w13 | #"e" => 0w14 | #"E" => 0w14
142 :     | #"f" => 0w15 | #"F" => 0w15
143 :     | _ => raise Fail "invalid unicode escape sequence")
144 :     fun iter (#"u"::_, v) = v
145 :     | iter (c::cs, v) = iter (cs, 0w16*v + (toW32 c))
146 :     | iter _ = raise Fail "invalid unicode escape sequence"
147 :     val uni = iter (List.rev (String.explode s), 0w0)
148 :     in iter (List.rev (String.explode s), 0w0)
149 :     end
150 :    
151 :     val highAscii = SIS.interval(0w128, 0w255)
152 :    
153 :    
154 :    
155 :     end
156 :    
157 :     local
158 :     fun mk yyins = let
159 :     (* current start state *)
160 :     val yyss = ref INITIAL
161 :     fun YYBEGIN ss = (yyss := ss)
162 :     (* current input stream *)
163 :     val yystrm = ref yyins
164 :     (* get one char of input *)
165 :     val yygetc = yyInput.getc
166 :     (* create yytext *)
167 :     fun yymktext(strm) = yyInput.subtract (strm, !yystrm)
168 :     open UserDeclarations
169 :     fun lex
170 :     (yyarg as ()) = let
171 :     fun yystuck (yyNO_MATCH) = raise Fail "stuck state"
172 :     | yystuck (yyMATCH (strm, action, old)) =
173 :     action (strm, old)
174 :     val yypos = yyInput.getpos (!yystrm)
175 :     fun continue() =
176 :     let
177 :     fun yyAction0 (strm, lastMatch) = let
178 :     val yylineno = ref(yyInput.getlineNo(!(yystrm)))
179 :     in
180 :     yystrm := strm; (YYBEGIN DEFS; LEXMARK(!yylineno, !yylineno))
181 :     end
182 : mblume 1912 fun yyAction1 (strm, lastMatch) = let
183 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
184 :     val yytext = yymktext(strm)
185 :     in
186 :     yystrm := strm; (DECLS(yytext, !yylineno, !yylineno))
187 :     end
188 : mblume 1912 fun yyAction2 (strm, lastMatch) = (yystrm := strm; (lex()))
189 :     fun yyAction3 (strm, lastMatch) = let
190 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
191 :     in
192 :     yystrm := strm; (YYBEGIN RE; LEXMARK(!yylineno, !yylineno))
193 :     end
194 : mblume 1912 fun yyAction4 (strm, lastMatch) = let
195 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
196 :     in
197 :     yystrm := strm; (YYBEGIN LEXSTATES; STATES(!yylineno, !yylineno))
198 :     end
199 : mblume 1912 fun yyAction5 (strm, lastMatch) = let
200 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
201 :     in
202 :     yystrm := strm;
203 :     (clrAction(); pcount := 1; inquote := false;
204 :     YYBEGIN ACTION;
205 :     afterAction := (fn () => YYBEGIN DEFS);
206 :     HEADER(!yylineno, !yylineno))
207 :     end
208 : mblume 1912 fun yyAction6 (strm, lastMatch) = let
209 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
210 :     in
211 :     yystrm := strm; (STRUCT(!yylineno, !yylineno))
212 :     end
213 : mblume 1912 fun yyAction7 (strm, lastMatch) = let
214 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
215 :     in
216 :     yystrm := strm;
217 :     (clrAction(); pcount := 1; inquote := false;
218 :     YYBEGIN ACTION;
219 :     afterAction := (fn () => YYBEGIN DEFS);
220 :     ARG(!yylineno, !yylineno))
221 :     end
222 : mblume 1912 fun yyAction8 (strm, lastMatch) = let
223 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
224 :     in
225 :     yystrm := strm; (COUNT(!yylineno, !yylineno))
226 :     end
227 : mblume 1912 fun yyAction9 (strm, lastMatch) = let
228 : mblume 1902 val oldStrm = !(yystrm)
229 :     fun REJECT () = (yystrm := oldStrm; yystuck(lastMatch))
230 :     val yylineno = ref(yyInput.getlineNo(!(yystrm)))
231 :     in
232 :     yystrm := strm; (REJECTTOK(!yylineno, !yylineno))
233 :     end
234 : mblume 1912 fun yyAction10 (strm, lastMatch) = let
235 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
236 :     in
237 :     yystrm := strm; (UNICODE(!yylineno, !yylineno))
238 :     end
239 : mblume 1912 fun yyAction11 (strm, lastMatch) = (yystrm := strm; (lex()))
240 :     fun yyAction12 (strm, lastMatch) = let
241 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
242 :     val yytext = yymktext(strm)
243 :     in
244 :     yystrm := strm; (ID(yytext, !yylineno, !yylineno))
245 :     end
246 : mblume 1912 fun yyAction13 (strm, lastMatch) = let
247 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
248 :     in
249 :     yystrm := strm; (YYBEGIN RE; EQ(!yylineno, !yylineno))
250 :     end
251 : mblume 1912 fun yyAction14 (strm, lastMatch) = (yystrm := strm; (lex()))
252 :     fun yyAction15 (strm, lastMatch) = let
253 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
254 :     in
255 :     yystrm := strm; (QMARK(!yylineno, !yylineno))
256 :     end
257 : mblume 1912 fun yyAction16 (strm, lastMatch) = let
258 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
259 :     in
260 :     yystrm := strm; (STAR(!yylineno, !yylineno))
261 :     end
262 : mblume 1912 fun yyAction17 (strm, lastMatch) = let
263 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
264 :     in
265 :     yystrm := strm; (PLUS(!yylineno, !yylineno))
266 :     end
267 : mblume 1912 fun yyAction18 (strm, lastMatch) = let
268 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
269 :     in
270 :     yystrm := strm; (BAR(!yylineno, !yylineno))
271 :     end
272 : mblume 1912 fun yyAction19 (strm, lastMatch) = let
273 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
274 :     in
275 :     yystrm := strm; (LP(!yylineno, !yylineno))
276 :     end
277 : mblume 1912 fun yyAction20 (strm, lastMatch) = let
278 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
279 :     in
280 :     yystrm := strm; (RP(!yylineno, !yylineno))
281 :     end
282 : mblume 1912 fun yyAction21 (strm, lastMatch) = let
283 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
284 :     in
285 :     yystrm := strm; (DOLLAR(!yylineno, !yylineno))
286 :     end
287 : mblume 1912 fun yyAction22 (strm, lastMatch) = let
288 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
289 :     in
290 :     yystrm := strm; (SLASH(!yylineno, !yylineno))
291 :     end
292 : mblume 1912 fun yyAction23 (strm, lastMatch) = let
293 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
294 :     in
295 :     yystrm := strm; (DOT(!yylineno, !yylineno))
296 :     end
297 : mblume 1912 fun yyAction24 (strm, lastMatch) = (yystrm := strm; (YYBEGIN RECB; lex()))
298 :     fun yyAction25 (strm, lastMatch) = (yystrm := strm; (YYBEGIN STRING; lex()))
299 :     fun yyAction26 (strm, lastMatch) = let
300 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
301 :     in
302 :     yystrm := strm; (YYBEGIN CHARCLASS; LB(!yylineno, !yylineno))
303 :     end
304 : mblume 1912 fun yyAction27 (strm, lastMatch) = let
305 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
306 :     in
307 :     yystrm := strm; (YYBEGIN LEXSTATES; LT(!yylineno, !yylineno))
308 :     end
309 : mblume 1912 fun yyAction28 (strm, lastMatch) = let
310 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
311 :     in
312 :     yystrm := strm; (GT(!yylineno, !yylineno))
313 :     end
314 : mblume 1912 fun yyAction29 (strm, lastMatch) = let
315 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
316 :     in
317 :     yystrm := strm;
318 :     (clrAction(); pcount := 1; inquote := false;
319 :     YYBEGIN ACTION;
320 :     afterAction := (fn () => YYBEGIN RE);
321 :     ARROW(!yylineno, !yylineno))
322 :     end
323 : mblume 1912 fun yyAction30 (strm, lastMatch) = let
324 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
325 :     in
326 :     yystrm := strm; (YYBEGIN DEFS; SEMI(!yylineno, !yylineno))
327 :     end
328 : mblume 1912 fun yyAction31 (strm, lastMatch) = (yystrm := strm; (lex()))
329 :     fun yyAction32 (strm, lastMatch) = let
330 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
331 :     val yytext = yymktext(strm)
332 :     in
333 :     yystrm := strm; (ID(yytext, !yylineno, !yylineno))
334 :     end
335 : mblume 1912 fun yyAction33 (strm, lastMatch) = let
336 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
337 :     val yytext = yymktext(strm)
338 :     in
339 :     yystrm := strm;
340 :     (REPS(valOf (Int.fromString yytext), !yylineno, !yylineno))
341 :     end
342 : mblume 1912 fun yyAction34 (strm, lastMatch) = let
343 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
344 :     in
345 :     yystrm := strm; (COMMA(!yylineno, !yylineno))
346 :     end
347 : mblume 1912 fun yyAction35 (strm, lastMatch) = let
348 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
349 :     in
350 :     yystrm := strm; (YYBEGIN RE; RCB(!yylineno, !yylineno))
351 :     end
352 : mblume 1912 fun yyAction36 (strm, lastMatch) = let
353 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
354 :     in
355 :     yystrm := strm; (YYBEGIN RE; RBD(!yylineno, !yylineno))
356 :     end
357 : mblume 1912 fun yyAction37 (strm, lastMatch) = let
358 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
359 :     in
360 :     yystrm := strm; (YYBEGIN RE; RB(!yylineno, !yylineno))
361 :     end
362 : mblume 1912 fun yyAction38 (strm, lastMatch) = let
363 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
364 :     in
365 :     yystrm := strm; (DASH(!yylineno, !yylineno))
366 :     end
367 : mblume 1912 fun yyAction39 (strm, lastMatch) = let
368 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
369 :     in
370 :     yystrm := strm; (CARAT(!yylineno, !yylineno))
371 :     end
372 : mblume 1912 fun yyAction40 (strm, lastMatch) = (yystrm := strm; (YYBEGIN RE; lex()))
373 :     fun yyAction41 (strm, lastMatch) = let
374 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
375 :     val yytext = yymktext(strm)
376 :     in
377 :     yystrm := strm;
378 :     (CHAR(valOf (String.fromString yytext), !yylineno, !yylineno))
379 :     end
380 : mblume 1912 fun yyAction42 (strm, lastMatch) = let
381 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
382 :     val yytext = yymktext(strm)
383 :     in
384 :     yystrm := strm; (UNICHAR(uniChar yytext, !yylineno, !yylineno))
385 :     end
386 : mblume 1912 fun yyAction43 (strm, lastMatch) = let
387 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
388 :     val yytext = yymktext(strm)
389 :     in
390 :     yystrm := strm;
391 :     (CHAR(String.substring (yytext, 1, 1), !yylineno, !yylineno))
392 :     end
393 : mblume 1912 fun yyAction44 (strm, lastMatch) = let
394 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
395 :     val yytext = yymktext(strm)
396 :     in
397 :     yystrm := strm; (CHAR(yytext, !yylineno, !yylineno))
398 :     end
399 : mblume 1912 fun yyAction45 (strm, lastMatch) = let
400 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
401 :     val yytext = yymktext(strm)
402 :     in
403 :     yystrm := strm; (LEXSTATE(yytext, !yylineno, !yylineno))
404 :     end
405 : mblume 1912 fun yyAction46 (strm, lastMatch) = (yystrm := strm; (lex()))
406 :     fun yyAction47 (strm, lastMatch) = let
407 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
408 :     in
409 :     yystrm := strm; (COMMA(!yylineno, !yylineno))
410 :     end
411 : mblume 1912 fun yyAction48 (strm, lastMatch) = let
412 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
413 :     in
414 :     yystrm := strm; (YYBEGIN RE; GT(!yylineno, !yylineno))
415 :     end
416 : mblume 1912 fun yyAction49 (strm, lastMatch) = let
417 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
418 :     in
419 :     yystrm := strm; (YYBEGIN DEFS; SEMI(!yylineno, !yylineno))
420 :     end
421 : mblume 1912 fun yyAction50 (strm, lastMatch) = let
422 : mblume 1902 val yylineno = ref(yyInput.getlineNo(!(yystrm)))
423 :     in
424 :     yystrm := strm;
425 :     (if !pcount = 0
426 :     then ((!afterAction)();
427 :     ACT(getAction(), !yylineno, !yylineno))
428 :     else (updAction ";"; lex()))
429 :     end
430 : mblume 1912 fun yyAction51 (strm, lastMatch) = (yystrm := strm;
431 : mblume 1902 (updAction "("; inc pcount; lex()))
432 : mblume 1912 fun yyAction52 (strm, lastMatch) = (yystrm := strm;
433 : mblume 1902 (updAction ")"; dec pcount; lex()))
434 : mblume 1912 fun yyAction53 (strm, lastMatch) = (yystrm := strm; (updAction "\\\""; lex()))
435 :     fun yyAction54 (strm, lastMatch) = (yystrm := strm; (updAction "\\\\"; lex()))
436 :     fun yyAction55 (strm, lastMatch) = (yystrm := strm; (updAction "\\"; lex()))
437 :     fun yyAction56 (strm, lastMatch) = (yystrm := strm;
438 : mblume 1902 (updAction "\""; inquote := not (!inquote); lex()))
439 : mblume 1912 fun yyAction57 (strm, lastMatch) = let
440 : mblume 1902 val yytext = yymktext(strm)
441 :     in
442 :     yystrm := strm; (updAction yytext; lex())
443 :     end
444 : mblume 1912 fun yyQ110 (strm, lastMatch) = (case (yygetc(strm))
445 :     of NONE => yyAction1(strm, yyNO_MATCH)
446 : mblume 1902 | SOME(inp, strm') =>
447 : mblume 1912 if inp = #"&"
448 :     then yyQ115(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
449 :     else if inp < #"&"
450 :     then if inp = #"%"
451 :     then yyQ114(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
452 :     else yyQ115(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
453 : mblume 1902 else if inp <= #"\127"
454 : mblume 1912 then yyQ115(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
455 :     else yyAction1(strm, yyNO_MATCH)
456 : mblume 1902 (* end case *))
457 : mblume 1912 and yyQ114 (strm, lastMatch) = (case (yygetc(strm))
458 : mblume 1902 of NONE => yystuck(lastMatch)
459 :     | SOME(inp, strm') =>
460 : mblume 1912 if inp = #"&"
461 :     then yyQ113(strm', lastMatch)
462 :     else if inp < #"&"
463 :     then if inp = #"%"
464 :     then yystuck(lastMatch)
465 :     else yyQ113(strm', lastMatch)
466 :     else if inp <= #"\127"
467 :     then yyQ113(strm', lastMatch)
468 : mblume 1902 else yystuck(lastMatch)
469 :     (* end case *))
470 : mblume 1912 and yyQ113 (strm, lastMatch) = (case (yygetc(strm))
471 :     of NONE => yyAction1(strm, yyNO_MATCH)
472 :     | SOME(inp, strm') =>
473 :     if inp = #"&"
474 :     then yyQ110(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
475 :     else if inp < #"&"
476 :     then if inp = #"%"
477 :     then yyQ114(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
478 :     else yyQ110(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
479 :     else if inp <= #"\127"
480 :     then yyQ110(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
481 :     else yyAction1(strm, yyNO_MATCH)
482 :     (* end case *))
483 :     and yyQ115 (strm, lastMatch) = (case (yygetc(strm))
484 :     of NONE => yyAction1(strm, yyNO_MATCH)
485 :     | SOME(inp, strm') =>
486 :     if inp = #"&"
487 :     then yyQ115(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
488 :     else if inp < #"&"
489 :     then if inp = #"%"
490 :     then yyQ114(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
491 :     else yyQ115(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
492 :     else if inp <= #"\127"
493 :     then yyQ115(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
494 :     else yyAction1(strm, yyNO_MATCH)
495 :     (* end case *))
496 :     fun yyQ112 (strm, lastMatch) = yyAction0(strm, yyNO_MATCH)
497 :     fun yyQ111 (strm, lastMatch) = (case (yygetc(strm))
498 : mblume 1902 of NONE => yystuck(lastMatch)
499 :     | SOME(inp, strm') =>
500 : mblume 1912 if inp = #"&"
501 :     then yyQ113(strm', lastMatch)
502 :     else if inp < #"&"
503 :     then if inp = #"%"
504 :     then yyQ112(strm', lastMatch)
505 :     else yyQ113(strm', lastMatch)
506 :     else if inp <= #"\127"
507 :     then yyQ113(strm', lastMatch)
508 : mblume 1902 else yystuck(lastMatch)
509 :     (* end case *))
510 : mblume 1912 fun yyQ7 (strm, lastMatch) = (case (yygetc(strm))
511 :     of NONE =>
512 :     if yyInput.eof(strm)
513 :     then UserDeclarations.eof(yyarg)
514 :     else yyAction1(strm, yyNO_MATCH)
515 : mblume 1902 | SOME(inp, strm') =>
516 : mblume 1912 if inp = #"&"
517 :     then yyQ110(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
518 :     else if inp < #"&"
519 :     then if inp = #"%"
520 :     then yyQ111(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
521 :     else yyQ110(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
522 :     else if inp <= #"\127"
523 :     then yyQ110(strm', yyMATCH(strm, yyAction1, yyNO_MATCH))
524 :     else if yyInput.eof(strm)
525 :     then UserDeclarations.eof(yyarg)
526 :     else yyAction1(strm, yyNO_MATCH)
527 :     (* end case *))
528 :     fun yyQ102 (strm, lastMatch) = yyAction50(strm, yyNO_MATCH)
529 :     fun yyQ103 (strm, lastMatch) = yyAction51(strm, yyNO_MATCH)
530 :     fun yyQ104 (strm, lastMatch) = yyAction52(strm, yyNO_MATCH)
531 :     fun yyQ105 (strm, lastMatch) = yyAction56(strm, yyNO_MATCH)
532 :     fun yyQ106 (strm, lastMatch) = (case (yygetc(strm))
533 :     of NONE => yyAction57(strm, yyNO_MATCH)
534 :     | SOME(inp, strm') =>
535 :     if inp = #";"
536 :     then yyAction57(strm, yyNO_MATCH)
537 :     else if inp < #";"
538 :     then if inp = #"#"
539 :     then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
540 :     else if inp < #"#"
541 :     then if inp = #"\""
542 :     then yyAction57(strm, yyNO_MATCH)
543 :     else yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
544 :     else if inp = #"("
545 :     then yyAction57(strm, yyNO_MATCH)
546 :     else if inp < #"("
547 :     then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
548 :     else if inp <= #")"
549 :     then yyAction57(strm, yyNO_MATCH)
550 :     else yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
551 : mblume 1902 else if inp = #"]"
552 : mblume 1912 then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
553 : mblume 1902 else if inp < #"]"
554 :     then if inp = #"\\"
555 : mblume 1912 then yyAction57(strm, yyNO_MATCH)
556 :     else yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
557 : mblume 1902 else if inp <= #"\127"
558 : mblume 1912 then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
559 :     else yyAction57(strm, yyNO_MATCH)
560 : mblume 1902 (* end case *))
561 : mblume 1912 fun yyQ108 (strm, lastMatch) = yyAction53(strm, yyNO_MATCH)
562 :     fun yyQ109 (strm, lastMatch) = yyAction54(strm, yyNO_MATCH)
563 :     fun yyQ107 (strm, lastMatch) = (case (yygetc(strm))
564 :     of NONE => yyAction55(strm, yyNO_MATCH)
565 : mblume 1902 | SOME(inp, strm') =>
566 : mblume 1912 if inp = #"#"
567 :     then yyAction55(strm, yyNO_MATCH)
568 :     else if inp < #"#"
569 :     then if inp = #"\""
570 :     then yyQ108(strm', yyMATCH(strm, yyAction55, yyNO_MATCH))
571 :     else yyAction55(strm, yyNO_MATCH)
572 :     else if inp = #"\\"
573 :     then yyQ109(strm', yyMATCH(strm, yyAction55, yyNO_MATCH))
574 :     else yyAction55(strm, yyNO_MATCH)
575 :     (* end case *))
576 :     fun yyQ6 (strm, lastMatch) = (case (yygetc(strm))
577 :     of NONE =>
578 :     if yyInput.eof(strm)
579 :     then UserDeclarations.eof(yyarg)
580 :     else yyAction57(strm, yyNO_MATCH)
581 :     | SOME(inp, strm') =>
582 :     if inp = #"*"
583 :     then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
584 :     else if inp < #"*"
585 :     then if inp = #"#"
586 :     then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
587 :     else if inp < #"#"
588 :     then if inp = #"\""
589 :     then yyQ105(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
590 :     else yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
591 :     else if inp = #"("
592 :     then yyQ103(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
593 :     else if inp = #")"
594 :     then yyQ104(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
595 :     else yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
596 :     else if inp = #"\\"
597 :     then yyQ107(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
598 : mblume 1902 else if inp < #"\\"
599 : mblume 1912 then if inp = #";"
600 :     then yyQ102(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
601 :     else yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
602 : mblume 1902 else if inp <= #"\127"
603 : mblume 1912 then yyQ106(strm', yyMATCH(strm, yyAction57, yyNO_MATCH))
604 :     else if yyInput.eof(strm)
605 :     then UserDeclarations.eof(yyarg)
606 :     else yyAction57(strm, yyNO_MATCH)
607 : mblume 1902 (* end case *))
608 : mblume 1912 fun yyQ97 (strm, lastMatch) = yyAction46(strm, yyNO_MATCH)
609 :     fun yyQ98 (strm, lastMatch) = yyAction47(strm, yyNO_MATCH)
610 :     fun yyQ99 (strm, lastMatch) = yyAction48(strm, yyNO_MATCH)
611 :     fun yyQ100 (strm, lastMatch) = yyAction49(strm, yyNO_MATCH)
612 :     fun yyQ101 (strm, lastMatch) = (case (yygetc(strm))
613 :     of NONE => yyAction45(strm, yyNO_MATCH)
614 : mblume 1902 | SOME(inp, strm') =>
615 : mblume 1912 if inp = #"A"
616 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
617 :     else if inp < #"A"
618 :     then if inp = #"("
619 :     then yyAction45(strm, yyNO_MATCH)
620 :     else if inp < #"("
621 :     then if inp = #"'"
622 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
623 :     else yyAction45(strm, yyNO_MATCH)
624 :     else if inp = #"0"
625 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
626 :     else if inp < #"0"
627 :     then yyAction45(strm, yyNO_MATCH)
628 :     else if inp <= #"9"
629 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
630 :     else yyAction45(strm, yyNO_MATCH)
631 :     else if inp = #"`"
632 :     then yyAction45(strm, yyNO_MATCH)
633 :     else if inp < #"`"
634 :     then if inp = #"["
635 :     then yyAction45(strm, yyNO_MATCH)
636 :     else if inp < #"["
637 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
638 :     else if inp = #"_"
639 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
640 :     else yyAction45(strm, yyNO_MATCH)
641 :     else if inp <= #"z"
642 :     then yyQ101(strm', yyMATCH(strm, yyAction45, yyNO_MATCH))
643 :     else yyAction45(strm, yyNO_MATCH)
644 :     (* end case *))
645 :     fun yyQ5 (strm, lastMatch) = (case (yygetc(strm))
646 :     of NONE =>
647 :     if yyInput.eof(strm)
648 :     then UserDeclarations.eof(yyarg)
649 :     else yystuck(lastMatch)
650 :     | SOME(inp, strm') =>
651 : mblume 1902 if inp = #"-"
652 : mblume 1912 then if yyInput.eof(strm)
653 :     then UserDeclarations.eof(yyarg)
654 :     else yystuck(lastMatch)
655 : mblume 1902 else if inp < #"-"
656 :     then if inp = #"\^N"
657 : mblume 1912 then if yyInput.eof(strm)
658 :     then UserDeclarations.eof(yyarg)
659 :     else yystuck(lastMatch)
660 : mblume 1902 else if inp < #"\^N"
661 :     then if inp = #"\v"
662 : mblume 1912 then if yyInput.eof(strm)
663 :     then UserDeclarations.eof(yyarg)
664 :     else yystuck(lastMatch)
665 : mblume 1902 else if inp < #"\v"
666 :     then if inp <= #"\b"
667 : mblume 1912 then if yyInput.eof(strm)
668 :     then UserDeclarations.eof(yyarg)
669 :     else yystuck(lastMatch)
670 :     else yyQ97(strm', lastMatch)
671 : mblume 1902 else if inp = #"\r"
672 : mblume 1912 then yyQ97(strm', lastMatch)
673 :     else if yyInput.eof(strm)
674 :     then UserDeclarations.eof(yyarg)
675 : mblume 1902 else yystuck(lastMatch)
676 :     else if inp = #"!"
677 : mblume 1912 then if yyInput.eof(strm)
678 :     then UserDeclarations.eof(yyarg)
679 :     else yystuck(lastMatch)
680 : mblume 1902 else if inp < #"!"
681 :     then if inp = #" "
682 : mblume 1912 then yyQ97(strm', lastMatch)
683 :     else if yyInput.eof(strm)
684 :     then UserDeclarations.eof(yyarg)
685 : mblume 1902 else yystuck(lastMatch)
686 :     else if inp = #","
687 : mblume 1912 then yyQ98(strm', lastMatch)
688 :     else if yyInput.eof(strm)
689 :     then UserDeclarations.eof(yyarg)
690 : mblume 1902 else yystuck(lastMatch)
691 :     else if inp = #"?"
692 : mblume 1912 then if yyInput.eof(strm)
693 :     then UserDeclarations.eof(yyarg)
694 :     else yystuck(lastMatch)
695 : mblume 1902 else if inp < #"?"
696 :     then if inp = #"<"
697 : mblume 1912 then if yyInput.eof(strm)
698 :     then UserDeclarations.eof(yyarg)
699 :     else yystuck(lastMatch)
700 : mblume 1902 else if inp < #"<"
701 :     then if inp = #";"
702 : mblume 1912 then yyQ100(strm', lastMatch)
703 :     else if yyInput.eof(strm)
704 :     then UserDeclarations.eof(yyarg)
705 : mblume 1902 else yystuck(lastMatch)
706 :     else if inp = #">"
707 : mblume 1912 then yyQ99(strm', lastMatch)
708 :     else if yyInput.eof(strm)
709 :     then UserDeclarations.eof(yyarg)
710 : mblume 1902 else yystuck(lastMatch)
711 :     else if inp = #"["
712 : mblume 1912 then if yyInput.eof(strm)
713 :     then UserDeclarations.eof(yyarg)
714 :     else yystuck(lastMatch)
715 : mblume 1902 else if inp < #"["
716 :     then if inp <= #"@"
717 : mblume 1912 then if yyInput.eof(strm)
718 :     then UserDeclarations.eof(yyarg)
719 :     else yystuck(lastMatch)
720 :     else yyQ101(strm', lastMatch)
721 : mblume 1902 else if inp = #"a"
722 : mblume 1912 then yyQ101(strm', lastMatch)
723 : mblume 1902 else if inp < #"a"
724 : mblume 1912 then if yyInput.eof(strm)
725 :     then UserDeclarations.eof(yyarg)
726 :     else yystuck(lastMatch)
727 : mblume 1902 else if inp <= #"z"
728 : mblume 1912 then yyQ101(strm', lastMatch)
729 :     else if yyInput.eof(strm)
730 :     then UserDeclarations.eof(yyarg)
731 : mblume 1902 else yystuck(lastMatch)
732 :     (* end case *))
733 : mblume 1912 fun yyQ93 (strm, lastMatch) = yyAction37(strm, yyNO_MATCH)
734 :     fun yyQ94 (strm, lastMatch) = yyAction39(strm, yyNO_MATCH)
735 :     fun yyQ25 (strm, lastMatch) = yyAction44(strm, yyNO_MATCH)
736 :     fun yyQ30 (strm, lastMatch) = yyAction41(strm, yyNO_MATCH)
737 :     fun yyQ31 (strm, lastMatch) = yyAction43(strm, yyNO_MATCH)
738 :     fun yyQ39 (strm, lastMatch) = yyAction42(strm, yyNO_MATCH)
739 :     fun yyQ38 (strm, lastMatch) = (case (yygetc(strm))
740 : mblume 1902 of NONE => yystuck(lastMatch)
741 :     | SOME(inp, strm') =>
742 : mblume 1912 if inp = #"A"
743 :     then yyQ39(strm', lastMatch)
744 :     else if inp < #"A"
745 :     then if inp = #"0"
746 :     then yyQ39(strm', lastMatch)
747 :     else if inp < #"0"
748 : mblume 1902 then yystuck(lastMatch)
749 : mblume 1912 else if inp <= #"9"
750 :     then yyQ39(strm', lastMatch)
751 : mblume 1902 else yystuck(lastMatch)
752 : mblume 1912 else if inp = #"a"
753 :     then yyQ39(strm', lastMatch)
754 :     else if inp < #"a"
755 :     then if inp <= #"F"
756 :     then yyQ39(strm', lastMatch)
757 : mblume 1902 else yystuck(lastMatch)
758 : mblume 1912 else if inp <= #"f"
759 :     then yyQ39(strm', lastMatch)
760 : mblume 1902 else yystuck(lastMatch)
761 :     (* end case *))
762 : mblume 1912 fun yyQ37 (strm, lastMatch) = (case (yygetc(strm))
763 :     of NONE => yystuck(lastMatch)
764 : mblume 1902 | SOME(inp, strm') =>
765 :     if inp = #"A"
766 : mblume 1912 then yyQ38(strm', lastMatch)
767 : mblume 1902 else if inp < #"A"
768 :     then if inp = #"0"
769 : mblume 1912 then yyQ38(strm', lastMatch)
770 : mblume 1902 else if inp < #"0"
771 : mblume 1912 then yystuck(lastMatch)
772 : mblume 1902 else if inp <= #"9"
773 : mblume 1912 then yyQ38(strm', lastMatch)
774 :     else yystuck(lastMatch)
775 : mblume 1902 else if inp = #"a"
776 : mblume 1912 then yyQ38(strm', lastMatch)
777 : mblume 1902 else if inp < #"a"
778 :     then if inp <= #"F"
779 : mblume 1912 then yyQ38(strm', lastMatch)
780 :     else yystuck(lastMatch)
781 : mblume 1902 else if inp <= #"f"
782 : mblume 1912 then yyQ38(strm', lastMatch)
783 : mblume 1902 else yystuck(lastMatch)
784 :     (* end case *))
785 : mblume 1912 fun yyQ36 (strm, lastMatch) = (case (yygetc(strm))
786 : mblume 1902 of NONE => yystuck(lastMatch)
787 :     | SOME(inp, strm') =>
788 :     if inp = #"A"
789 :     then yyQ37(strm', lastMatch)
790 :     else if inp < #"A"
791 :     then if inp = #"0"
792 :     then yyQ37(strm', lastMatch)
793 :     else if inp < #"0"
794 :     then yystuck(lastMatch)
795 :     else if inp <= #"9"
796 :     then yyQ37(strm', lastMatch)
797 :     else yystuck(lastMatch)
798 :     else if inp = #"a"
799 :     then yyQ37(strm', lastMatch)
800 :     else if inp < #"a"
801 :     then if inp <= #"F"
802 :     then yyQ37(strm', lastMatch)
803 :     else yystuck(lastMatch)
804 :     else if inp <= #"f"
805 :     then yyQ37(strm', lastMatch)
806 :     else yystuck(lastMatch)
807 :     (* end case *))
808 : mblume 1912 fun yyQ32 (strm, lastMatch) = (case (yygetc(strm))
809 :     of NONE => yyAction43(strm, yyNO_MATCH)
810 : mblume 1902 | SOME(inp, strm') =>
811 :     if inp = #"A"
812 : mblume 1912 then yyQ36(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
813 : mblume 1902 else if inp < #"A"
814 :     then if inp = #"0"
815 : mblume 1912 then yyQ36(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
816 : mblume 1902 else if inp < #"0"
817 : mblume 1912 then yyAction43(strm, yyNO_MATCH)
818 : mblume 1902 else if inp <= #"9"
819 : mblume 1912 then yyQ36(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
820 :     else yyAction43(strm, yyNO_MATCH)
821 : mblume 1902 else if inp = #"a"
822 : mblume 1912 then yyQ36(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
823 : mblume 1902 else if inp < #"a"
824 :     then if inp <= #"F"
825 : mblume 1912 then yyQ36(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
826 :     else yyAction43(strm, yyNO_MATCH)
827 : mblume 1902 else if inp <= #"f"
828 : mblume 1912 then yyQ36(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
829 :     else yyAction43(strm, yyNO_MATCH)
830 : mblume 1902 (* end case *))
831 : mblume 1912 fun yyQ35 (strm, lastMatch) = yyAction41(strm, yyNO_MATCH)
832 :     fun yyQ34 (strm, lastMatch) = (case (yygetc(strm))
833 : mblume 1902 of NONE => yystuck(lastMatch)
834 :     | SOME(inp, strm') =>
835 : mblume 1912 if inp = #"0"
836 :     then yyQ35(strm', lastMatch)
837 :     else if inp < #"0"
838 :     then yystuck(lastMatch)
839 :     else if inp <= #"9"
840 :     then yyQ35(strm', lastMatch)
841 :     else yystuck(lastMatch)
842 :     (* end case *))
843 :     fun yyQ33 (strm, lastMatch) = (case (yygetc(strm))
844 :     of NONE => yyAction43(strm, yyNO_MATCH)
845 :     | SOME(inp, strm') =>
846 :     if inp = #"0"
847 :     then yyQ34(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
848 :     else if inp < #"0"
849 :     then yyAction43(strm, yyNO_MATCH)
850 :     else if inp <= #"9"
851 :     then yyQ34(strm', yyMATCH(strm, yyAction43, yyNO_MATCH))
852 :     else yyAction43(strm, yyNO_MATCH)
853 :     (* end case *))
854 :     fun yyQ26 (strm, lastMatch) = (case (yygetc(strm))
855 :     of NONE => yyAction44(strm, yyNO_MATCH)
856 :     | SOME(inp, strm') =>
857 :     if inp = #"b"
858 :     then yyQ30(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
859 :     else if inp < #"b"
860 :     then if inp = #"#"
861 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
862 :     else if inp < #"#"
863 :     then if inp = #"\v"
864 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
865 :     else if inp < #"\v"
866 :     then if inp = #"\n"
867 :     then yyAction44(strm, yyNO_MATCH)
868 :     else yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
869 :     else if inp = #"\""
870 :     then yyQ30(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
871 :     else yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
872 :     else if inp = #":"
873 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
874 :     else if inp < #":"
875 :     then if inp <= #"/"
876 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
877 :     else yyQ33(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
878 :     else if inp = #"\\"
879 :     then yyQ30(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
880 :     else yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
881 :     else if inp = #"s"
882 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
883 :     else if inp < #"s"
884 :     then if inp = #"o"
885 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
886 :     else if inp < #"o"
887 :     then if inp = #"n"
888 :     then yyQ30(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
889 :     else yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
890 :     else if inp = #"r"
891 :     then yyQ30(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
892 :     else yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
893 :     else if inp = #"v"
894 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
895 :     else if inp < #"v"
896 :     then if inp = #"t"
897 :     then yyQ30(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
898 :     else yyQ32(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
899 :     else if inp <= #"\127"
900 :     then yyQ31(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
901 :     else yyAction44(strm, yyNO_MATCH)
902 :     (* end case *))
903 :     fun yyQ96 (strm, lastMatch) = yyAction36(strm, yyNO_MATCH)
904 :     fun yyQ95 (strm, lastMatch) = (case (yygetc(strm))
905 :     of NONE => yyAction38(strm, yyNO_MATCH)
906 :     | SOME(inp, strm') =>
907 :     if inp = #"]"
908 :     then yyQ96(strm', yyMATCH(strm, yyAction38, yyNO_MATCH))
909 :     else yyAction38(strm, yyNO_MATCH)
910 :     (* end case *))
911 :     fun yyQ4 (strm, lastMatch) = (case (yygetc(strm))
912 :     of NONE =>
913 :     if yyInput.eof(strm)
914 :     then UserDeclarations.eof(yyarg)
915 :     else yystuck(lastMatch)
916 :     | SOME(inp, strm') =>
917 :     if inp = #"\\"
918 :     then yyQ26(strm', lastMatch)
919 :     else if inp < #"\\"
920 :     then if inp = #"\v"
921 :     then yyQ25(strm', lastMatch)
922 :     else if inp < #"\v"
923 :     then if inp = #"\n"
924 :     then if yyInput.eof(strm)
925 :     then UserDeclarations.eof(yyarg)
926 :     else yystuck(lastMatch)
927 :     else yyQ25(strm', lastMatch)
928 :     else if inp = #"-"
929 :     then yyQ95(strm', lastMatch)
930 :     else yyQ25(strm', lastMatch)
931 :     else if inp = #"_"
932 :     then yyQ25(strm', lastMatch)
933 :     else if inp < #"_"
934 :     then if inp = #"]"
935 :     then yyQ93(strm', lastMatch)
936 :     else yyQ94(strm', lastMatch)
937 :     else if inp <= #"\127"
938 :     then yyQ25(strm', lastMatch)
939 :     else if yyInput.eof(strm)
940 :     then UserDeclarations.eof(yyarg)
941 :     else yystuck(lastMatch)
942 :     (* end case *))
943 :     fun yyQ92 (strm, lastMatch) = yyAction40(strm, yyNO_MATCH)
944 :     fun yyQ3 (strm, lastMatch) = (case (yygetc(strm))
945 :     of NONE =>
946 :     if yyInput.eof(strm)
947 :     then UserDeclarations.eof(yyarg)
948 :     else yystuck(lastMatch)
949 :     | SOME(inp, strm') =>
950 :     if inp = #"#"
951 :     then yyQ25(strm', lastMatch)
952 :     else if inp < #"#"
953 :     then if inp = #"\v"
954 :     then yyQ25(strm', lastMatch)
955 :     else if inp < #"\v"
956 :     then if inp = #"\n"
957 :     then if yyInput.eof(strm)
958 :     then UserDeclarations.eof(yyarg)
959 :     else yystuck(lastMatch)
960 :     else yyQ25(strm', lastMatch)
961 :     else if inp = #"\""
962 :     then yyQ92(strm', lastMatch)
963 :     else yyQ25(strm', lastMatch)
964 :     else if inp = #"]"
965 :     then yyQ25(strm', lastMatch)
966 :     else if inp < #"]"
967 :     then if inp = #"\\"
968 :     then yyQ26(strm', lastMatch)
969 :     else yyQ25(strm', lastMatch)
970 :     else if inp <= #"\127"
971 :     then yyQ25(strm', lastMatch)
972 :     else if yyInput.eof(strm)
973 :     then UserDeclarations.eof(yyarg)
974 :     else yystuck(lastMatch)
975 :     (* end case *))
976 :     fun yyQ87 (strm, lastMatch) = yyAction31(strm, yyNO_MATCH)
977 :     fun yyQ88 (strm, lastMatch) = yyAction34(strm, yyNO_MATCH)
978 :     fun yyQ89 (strm, lastMatch) = yyAction35(strm, yyNO_MATCH)
979 :     fun yyQ90 (strm, lastMatch) = (case (yygetc(strm))
980 :     of NONE => yyAction33(strm, yyNO_MATCH)
981 :     | SOME(inp, strm') =>
982 :     if inp = #"0"
983 :     then yyQ90(strm', yyMATCH(strm, yyAction33, yyNO_MATCH))
984 :     else if inp < #"0"
985 :     then yyAction33(strm, yyNO_MATCH)
986 :     else if inp <= #"9"
987 :     then yyQ90(strm', yyMATCH(strm, yyAction33, yyNO_MATCH))
988 :     else yyAction33(strm, yyNO_MATCH)
989 :     (* end case *))
990 :     fun yyQ91 (strm, lastMatch) = (case (yygetc(strm))
991 :     of NONE => yyAction32(strm, yyNO_MATCH)
992 :     | SOME(inp, strm') =>
993 : mblume 1902 if inp = #"A"
994 : mblume 1912 then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
995 : mblume 1902 else if inp < #"A"
996 : mblume 1912 then if inp = #"("
997 :     then yyAction32(strm, yyNO_MATCH)
998 :     else if inp < #"("
999 :     then if inp = #"'"
1000 :     then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
1001 :     else yyAction32(strm, yyNO_MATCH)
1002 :     else if inp = #"0"
1003 :     then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
1004 : mblume 1902 else if inp < #"0"
1005 : mblume 1912 then yyAction32(strm, yyNO_MATCH)
1006 : mblume 1902 else if inp <= #"9"
1007 : mblume 1912 then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
1008 :     else yyAction32(strm, yyNO_MATCH)
1009 :     else if inp = #"`"
1010 :     then yyAction32(strm, yyNO_MATCH)
1011 :     else if inp < #"`"
1012 :     then if inp = #"["
1013 :     then yyAction32(strm, yyNO_MATCH)
1014 :     else if inp < #"["
1015 :     then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
1016 :     else if inp = #"_"
1017 :     then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
1018 :     else yyAction32(strm, yyNO_MATCH)
1019 :     else if inp <= #"z"
1020 :     then yyQ91(strm', yyMATCH(strm, yyAction32, yyNO_MATCH))
1021 :     else yyAction32(strm, yyNO_MATCH)
1022 :     (* end case *))
1023 :     fun yyQ2 (strm, lastMatch) = (case (yygetc(strm))
1024 :     of NONE =>
1025 :     if yyInput.eof(strm)
1026 :     then UserDeclarations.eof(yyarg)
1027 :     else yystuck(lastMatch)
1028 :     | SOME(inp, strm') =>
1029 :     if inp = #"-"
1030 :     then if yyInput.eof(strm)
1031 :     then UserDeclarations.eof(yyarg)
1032 : mblume 1902 else yystuck(lastMatch)
1033 : mblume 1912 else if inp < #"-"
1034 :     then if inp = #"\^N"
1035 :     then if yyInput.eof(strm)
1036 :     then UserDeclarations.eof(yyarg)
1037 :     else yystuck(lastMatch)
1038 :     else if inp < #"\^N"
1039 :     then if inp = #"\v"
1040 :     then if yyInput.eof(strm)
1041 :     then UserDeclarations.eof(yyarg)
1042 :     else yystuck(lastMatch)
1043 :     else if inp < #"\v"
1044 :     then if inp <= #"\b"
1045 :     then if yyInput.eof(strm)
1046 :     then UserDeclarations.eof(yyarg)
1047 :     else yystuck(lastMatch)
1048 :     else yyQ87(strm', lastMatch)
1049 :     else if inp = #"\r"
1050 :     then yyQ87(strm', lastMatch)
1051 :     else if yyInput.eof(strm)
1052 :     then UserDeclarations.eof(yyarg)
1053 :     else yystuck(lastMatch)
1054 :     else if inp = #"!"
1055 :     then if yyInput.eof(strm)
1056 :     then UserDeclarations.eof(yyarg)
1057 :     else yystuck(lastMatch)
1058 :     else if inp < #"!"
1059 :     then if inp = #" "
1060 :     then yyQ87(strm', lastMatch)
1061 :     else if yyInput.eof(strm)
1062 :     then UserDeclarations.eof(yyarg)
1063 :     else yystuck(lastMatch)
1064 :     else if inp = #","
1065 :     then yyQ88(strm', lastMatch)
1066 :     else if yyInput.eof(strm)
1067 :     then UserDeclarations.eof(yyarg)
1068 : mblume 1902 else yystuck(lastMatch)
1069 : mblume 1912 else if inp = #"["
1070 :     then if yyInput.eof(strm)
1071 :     then UserDeclarations.eof(yyarg)
1072 :     else yystuck(lastMatch)
1073 :     else if inp < #"["
1074 :     then if inp = #":"
1075 :     then if yyInput.eof(strm)
1076 :     then UserDeclarations.eof(yyarg)
1077 :     else yystuck(lastMatch)
1078 :     else if inp < #":"
1079 :     then if inp <= #"/"
1080 :     then if yyInput.eof(strm)
1081 :     then UserDeclarations.eof(yyarg)
1082 :     else yystuck(lastMatch)
1083 :     else yyQ90(strm', lastMatch)
1084 :     else if inp <= #"@"
1085 :     then if yyInput.eof(strm)
1086 :     then UserDeclarations.eof(yyarg)
1087 :     else yystuck(lastMatch)
1088 :     else yyQ91(strm', lastMatch)
1089 :     else if inp = #"{"
1090 :     then if yyInput.eof(strm)
1091 :     then UserDeclarations.eof(yyarg)
1092 :     else yystuck(lastMatch)
1093 :     else if inp < #"{"
1094 :     then if inp <= #"`"
1095 :     then if yyInput.eof(strm)
1096 :     then UserDeclarations.eof(yyarg)
1097 :     else yystuck(lastMatch)
1098 :     else yyQ91(strm', lastMatch)
1099 :     else if inp = #"}"
1100 :     then yyQ89(strm', lastMatch)
1101 :     else if yyInput.eof(strm)
1102 :     then UserDeclarations.eof(yyarg)
1103 : mblume 1902 else yystuck(lastMatch)
1104 :     (* end case *))
1105 : mblume 1912 fun yyQ40 (strm, lastMatch) = yyAction2(strm, yyNO_MATCH)
1106 :     fun yyQ41 (strm, lastMatch) = yyAction13(strm, yyNO_MATCH)
1107 :     fun yyQ42 (strm, lastMatch) = (case (yygetc(strm))
1108 :     of NONE => yyAction12(strm, yyNO_MATCH)
1109 : mblume 1902 | SOME(inp, strm') =>
1110 :     if inp = #"A"
1111 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1112 : mblume 1902 else if inp < #"A"
1113 :     then if inp = #"("
1114 : mblume 1912 then yyAction12(strm, yyNO_MATCH)
1115 : mblume 1902 else if inp < #"("
1116 :     then if inp = #"'"
1117 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1118 :     else yyAction12(strm, yyNO_MATCH)
1119 : mblume 1902 else if inp = #"0"
1120 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1121 : mblume 1902 else if inp < #"0"
1122 : mblume 1912 then yyAction12(strm, yyNO_MATCH)
1123 : mblume 1902 else if inp <= #"9"
1124 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1125 :     else yyAction12(strm, yyNO_MATCH)
1126 : mblume 1902 else if inp = #"`"
1127 : mblume 1912 then yyAction12(strm, yyNO_MATCH)
1128 : mblume 1902 else if inp < #"`"
1129 :     then if inp = #"["
1130 : mblume 1912 then yyAction12(strm, yyNO_MATCH)
1131 : mblume 1902 else if inp < #"["
1132 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1133 : mblume 1902 else if inp = #"_"
1134 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1135 :     else yyAction12(strm, yyNO_MATCH)
1136 : mblume 1902 else if inp <= #"z"
1137 : mblume 1912 then yyQ42(strm', yyMATCH(strm, yyAction12, yyNO_MATCH))
1138 :     else yyAction12(strm, yyNO_MATCH)
1139 : mblume 1902 (* end case *))
1140 : mblume 1912 fun yyQ44 (strm, lastMatch) = yyAction3(strm, yyNO_MATCH)
1141 :     fun yyQ86 (strm, lastMatch) = yyAction6(strm, yyNO_MATCH)
1142 :     fun yyQ85 (strm, lastMatch) = (case (yygetc(strm))
1143 : mblume 1902 of NONE => yystuck(lastMatch)
1144 :     | SOME(inp, strm') =>
1145 : mblume 1912 if inp = #"e"
1146 :     then yyQ86(strm', lastMatch)
1147 : mblume 1902 else yystuck(lastMatch)
1148 :     (* end case *))
1149 : mblume 1912 fun yyQ84 (strm, lastMatch) = (case (yygetc(strm))
1150 :     of NONE => yystuck(lastMatch)
1151 : mblume 1902 | SOME(inp, strm') =>
1152 : mblume 1912 if inp = #"r"
1153 :     then yyQ85(strm', lastMatch)
1154 :     else yystuck(lastMatch)
1155 : mblume 1902 (* end case *))
1156 : mblume 1912 fun yyQ83 (strm, lastMatch) = (case (yygetc(strm))
1157 : mblume 1902 of NONE => yystuck(lastMatch)
1158 :     | SOME(inp, strm') =>
1159 : mblume 1912 if inp = #"u"
1160 :     then yyQ84(strm', lastMatch)
1161 : mblume 1902 else yystuck(lastMatch)
1162 :     (* end case *))
1163 : mblume 1912 fun yyQ82 (strm, lastMatch) = (case (yygetc(strm))
1164 : mblume 1902 of NONE => yystuck(lastMatch)
1165 :     | SOME(inp, strm') =>
1166 : mblume 1912 if inp = #"t"
1167 :     then yyQ83(strm', lastMatch)
1168 : mblume 1902 else yystuck(lastMatch)
1169 :     (* end case *))
1170 : mblume 1912 fun yyQ81 (strm, lastMatch) = (case (yygetc(strm))
1171 : mblume 1902 of NONE => yystuck(lastMatch)
1172 :     | SOME(inp, strm') =>
1173 : mblume 1912 if inp = #"c"
1174 :     then yyQ82(strm', lastMatch)
1175 : mblume 1902 else yystuck(lastMatch)
1176 :     (* end case *))
1177 : mblume 1912 fun yyQ80 (strm, lastMatch) = (case (yygetc(strm))
1178 : mblume 1902 of NONE => yystuck(lastMatch)
1179 :     | SOME(inp, strm') =>
1180 : mblume 1912 if inp = #"u"
1181 :     then yyQ81(strm', lastMatch)
1182 : mblume 1902 else yystuck(lastMatch)
1183 :     (* end case *))
1184 : mblume 1912 fun yyQ79 (strm, lastMatch) = (case (yygetc(strm))
1185 : mblume 1902 of NONE => yystuck(lastMatch)
1186 :     | SOME(inp, strm') =>
1187 : mblume 1912 if inp = #"r"
1188 :     then yyQ80(strm', lastMatch)
1189 : mblume 1902 else yystuck(lastMatch)
1190 :     (* end case *))
1191 : mblume 1912 fun yyQ45 (strm, lastMatch) = (case (yygetc(strm))
1192 :     of NONE => yyAction4(strm, yyNO_MATCH)
1193 :     | SOME(inp, strm') =>
1194 :     if inp = #"t"
1195 :     then yyQ79(strm', yyMATCH(strm, yyAction4, yyNO_MATCH))
1196 :     else yyAction4(strm, yyNO_MATCH)
1197 :     (* end case *))
1198 :     fun yyQ78 (strm, lastMatch) = yyAction11(strm, yyNO_MATCH)
1199 :     fun yyQ77 (strm, lastMatch) = (case (yygetc(strm))
1200 : mblume 1902 of NONE => yystuck(lastMatch)
1201 :     | SOME(inp, strm') =>
1202 : mblume 1912 if inp = #"l"
1203 :     then yyQ78(strm', lastMatch)
1204 : mblume 1902 else yystuck(lastMatch)
1205 :     (* end case *))
1206 : mblume 1912 fun yyQ76 (strm, lastMatch) = (case (yygetc(strm))
1207 : mblume 1902 of NONE => yystuck(lastMatch)
1208 :     | SOME(inp, strm') =>
1209 : mblume 1912 if inp = #"l"
1210 :     then yyQ77(strm', lastMatch)
1211 : mblume 1902 else yystuck(lastMatch)
1212 :     (* end case *))
1213 : mblume 1912 fun yyQ46 (strm, lastMatch) = (case (yygetc(strm))
1214 : mblume 1902 of NONE => yystuck(lastMatch)
1215 :     | SOME(inp, strm') =>
1216 : mblume 1912 if inp = #"u"
1217 :     then yyQ76(strm', lastMatch)
1218 : mblume 1902 else yystuck(lastMatch)
1219 :     (* end case *))
1220 : mblume 1912 fun yyQ75 (strm, lastMatch) = yyAction10(strm, yyNO_MATCH)
1221 :     fun yyQ74 (strm, lastMatch) = (case (yygetc(strm))
1222 : mblume 1902 of NONE => yystuck(lastMatch)
1223 :     | SOME(inp, strm') =>
1224 : mblume 1912 if inp = #"e"
1225 :     then yyQ75(strm', lastMatch)
1226 : mblume 1902 else yystuck(lastMatch)
1227 :     (* end case *))
1228 : mblume 1912 fun yyQ73 (strm, lastMatch) = (case (yygetc(strm))
1229 : mblume 1902 of NONE => yystuck(lastMatch)
1230 :     | SOME(inp, strm') =>
1231 : mblume 1912 if inp = #"d"
1232 :     then yyQ74(strm', lastMatch)
1233 : mblume 1902 else yystuck(lastMatch)
1234 :     (* end case *))
1235 : mblume 1912 fun yyQ72 (strm, lastMatch) = (case (yygetc(strm))
1236 : mblume 1902 of NONE => yystuck(lastMatch)
1237 :     | SOME(inp, strm') =>
1238 : mblume 1912 if inp = #"o"
1239 :     then yyQ73(strm', lastMatch)
1240 : mblume 1902 else yystuck(lastMatch)
1241 :     (* end case *))
1242 : mblume 1912 fun yyQ71 (strm, lastMatch) = (case (yygetc(strm))
1243 : mblume 1902 of NONE => yystuck(lastMatch)
1244 :     | SOME(inp, strm') =>
1245 : mblume 1912 if inp = #"c"
1246 :     then yyQ72(strm', lastMatch)
1247 : mblume 1902 else yystuck(lastMatch)
1248 :     (* end case *))
1249 : mblume 1912 fun yyQ70 (strm, lastMatch) = (case (yygetc(strm))
1250 : mblume 1902 of NONE => yystuck(lastMatch)
1251 :     | SOME(inp, strm') =>
1252 : mblume 1912 if inp = #"i"
1253 :     then yyQ71(strm', lastMatch)
1254 : mblume 1902 else yystuck(lastMatch)
1255 :     (* end case *))
1256 : mblume 1912 fun yyQ47 (strm, lastMatch) = (case (yygetc(strm))
1257 : mblume 1902 of NONE => yystuck(lastMatch)
1258 :     | SOME(inp, strm') =>
1259 :     if inp = #"n"
1260 : mblume 1912 then yyQ70(strm', lastMatch)
1261 : mblume 1902 else yystuck(lastMatch)
1262 :     (* end case *))
1263 : mblume 1912 fun yyQ69 (strm, lastMatch) = yyAction9(strm, lastMatch)
1264 :     fun yyQ68 (strm, lastMatch) = (case (yygetc(strm))
1265 : mblume 1902 of NONE => yystuck(lastMatch)
1266 :     | SOME(inp, strm') =>
1267 :     if inp = #"t"
1268 : mblume 1912 then yyQ69(strm', lastMatch)
1269 : mblume 1902 else yystuck(lastMatch)
1270 :     (* end case *))
1271 : mblume 1912 fun yyQ67 (strm, lastMatch) = (case (yygetc(strm))
1272 : mblume 1902 of NONE => yystuck(lastMatch)
1273 :     | SOME(inp, strm') =>
1274 : mblume 1912 if inp = #"c"
1275 :     then yyQ68(strm', lastMatch)
1276 : mblume 1902 else yystuck(lastMatch)
1277 :     (* end case *))
1278 : mblume 1912 fun yyQ66 (strm, lastMatch) = (case (yygetc(strm))
1279 : mblume 1902 of NONE => yystuck(lastMatch)
1280 :     | SOME(inp, strm') =>
1281 :     if inp = #"e"
1282 : mblume 1912 then yyQ67(strm', lastMatch)
1283 :     else yystuck(lastMatch)
1284 :     (* end case *))
1285 :     fun yyQ65 (strm, lastMatch) = (case (yygetc(strm))
1286 :     of NONE => yystuck(lastMatch)
1287 :     | SOME(inp, strm') =>
1288 :     if inp = #"j"
1289 : mblume 1902 then yyQ66(strm', lastMatch)
1290 :     else yystuck(lastMatch)
1291 :     (* end case *))
1292 : mblume 1912 fun yyQ48 (strm, lastMatch) = (case (yygetc(strm))
1293 : mblume 1902 of NONE => yystuck(lastMatch)
1294 :     | SOME(inp, strm') =>
1295 : mblume 1912 if inp = #"e"
1296 :     then yyQ65(strm', lastMatch)
1297 : mblume 1902 else yystuck(lastMatch)
1298 :     (* end case *))
1299 : mblume 1912 fun yyQ64 (strm, lastMatch) = yyAction8(strm, yyNO_MATCH)
1300 :     fun yyQ63 (strm, lastMatch) = (case (yygetc(strm))
1301 : mblume 1902 of NONE => yystuck(lastMatch)
1302 :     | SOME(inp, strm') =>
1303 :     if inp = #"t"
1304 : mblume 1912 then yyQ64(strm', lastMatch)
1305 : mblume 1902 else yystuck(lastMatch)
1306 :     (* end case *))
1307 : mblume 1912 fun yyQ62 (strm, lastMatch) = (case (yygetc(strm))
1308 : mblume 1902 of NONE => yystuck(lastMatch)
1309 :     | SOME(inp, strm') =>
1310 : mblume 1912 if inp = #"n"
1311 :     then yyQ63(strm', lastMatch)
1312 : mblume 1902 else yystuck(lastMatch)
1313 :     (* end case *))
1314 : mblume 1912 fun yyQ61 (strm, lastMatch) = (case (yygetc(strm))
1315 : mblume 1902 of NONE => yystuck(lastMatch)
1316 :     | SOME(inp, strm') =>
1317 : mblume 1912 if inp = #"u"
1318 :     then yyQ62(strm', lastMatch)
1319 : mblume 1902 else yystuck(lastMatch)
1320 :     (* end case *))
1321 : mblume 1912 fun yyQ49 (strm, lastMatch) = (case (yygetc(strm))
1322 : mblume 1902 of NONE => yystuck(lastMatch)
1323 :     | SOME(inp, strm') =>
1324 :     if inp = #"o"
1325 : mblume 1912 then yyQ61(strm', lastMatch)
1326 : mblume 1902 else yystuck(lastMatch)
1327 :     (* end case *))
1328 : mblume 1912 fun yyQ60 (strm, lastMatch) = yyAction7(strm, yyNO_MATCH)
1329 :     fun yyQ59 (strm, lastMatch) = (case (yygetc(strm))
1330 : mblume 1902 of NONE => yystuck(lastMatch)
1331 :     | SOME(inp, strm') =>
1332 : mblume 1912 if inp = #"\^N"
1333 :     then yystuck(lastMatch)
1334 :     else if inp < #"\^N"
1335 :     then if inp = #"\v"
1336 :     then yystuck(lastMatch)
1337 :     else if inp < #"\v"
1338 :     then if inp <= #"\b"
1339 :     then yystuck(lastMatch)
1340 :     else yyQ59(strm', lastMatch)
1341 :     else if inp = #"\r"
1342 :     then yyQ59(strm', lastMatch)
1343 :     else yystuck(lastMatch)
1344 :     else if inp = #"!"
1345 :     then yystuck(lastMatch)
1346 :     else if inp < #"!"
1347 :     then if inp = #" "
1348 :     then yyQ59(strm', lastMatch)
1349 :     else yystuck(lastMatch)
1350 :     else if inp = #"("
1351 :     then yyQ60(strm', lastMatch)
1352 : mblume 1902 else yystuck(lastMatch)
1353 :     (* end case *))
1354 : mblume 1912 fun yyQ58 (strm, lastMatch) = (case (yygetc(strm))
1355 : mblume 1902 of NONE => yystuck(lastMatch)
1356 :     | SOME(inp, strm') =>
1357 : mblume 1912 if inp = #"g"
1358 :     then yyQ59(strm', lastMatch)
1359 : mblume 1902 else yystuck(lastMatch)
1360 :     (* end case *))
1361 : mblume 1912 fun yyQ50 (strm, lastMatch) = (case (yygetc(strm))
1362 : mblume 1902 of NONE => yystuck(lastMatch)
1363 :     | SOME(inp, strm') =>
1364 :     if inp = #"r"
1365 : mblume 1912 then yyQ58(strm', lastMatch)
1366 : mblume 1902 else yystuck(lastMatch)
1367 :     (* end case *))
1368 : mblume 1912 fun yyQ57 (strm, lastMatch) = yyAction5(strm, yyNO_MATCH)
1369 :     fun yyQ56 (strm, lastMatch) = (case (yygetc(strm))
1370 : mblume 1902 of NONE => yystuck(lastMatch)
1371 :     | SOME(inp, strm') =>
1372 : mblume 1912 if inp = #"\^N"
1373 :     then yystuck(lastMatch)
1374 :     else if inp < #"\^N"
1375 :     then if inp = #"\v"
1376 :     then yystuck(lastMatch)
1377 :     else if inp < #"\v"
1378 :     then if inp <= #"\b"
1379 :     then yystuck(lastMatch)
1380 :     else yyQ56(strm', lastMatch)
1381 :     else if inp = #"\r"
1382 :     then yyQ56(strm', lastMatch)
1383 :     else yystuck(lastMatch)
1384 :     else if inp = #"!"
1385 :     then yystuck(lastMatch)
1386 :     else if inp < #"!"
1387 :     then if inp = #" "
1388 :     then yyQ56(strm', lastMatch)
1389 :     else yystuck(lastMatch)
1390 :     else if inp = #"("
1391 :     then yyQ57(strm', lastMatch)
1392 : mblume 1902 else yystuck(lastMatch)
1393 :     (* end case *))
1394 : mblume 1912 fun yyQ55 (strm, lastMatch) = (case (yygetc(strm))
1395 : mblume 1902 of NONE => yystuck(lastMatch)
1396 :     | SOME(inp, strm') =>
1397 : mblume 1912 if inp = #"r"
1398 :     then yyQ56(strm', lastMatch)
1399 : mblume 1902 else yystuck(lastMatch)
1400 :     (* end case *))
1401 : mblume 1912 fun yyQ54 (strm, lastMatch) = (case (yygetc(strm))
1402 : mblume 1902 of NONE => yystuck(lastMatch)
1403 :     | SOME(inp, strm') =>
1404 : mblume 1912 if inp = #"e"
1405 :     then yyQ55(strm', lastMatch)
1406 : mblume 1902 else yystuck(lastMatch)
1407 :     (* end case *))
1408 : mblume 1912 fun yyQ53 (strm, lastMatch) = (case (yygetc(strm))
1409 : mblume 1902 of NONE => yystuck(lastMatch)
1410 :     | SOME(inp, strm') =>
1411 : mblume 1912 if inp = #"d"
1412 :     then yyQ54(strm', lastMatch)
1413 : mblume 1902 else yystuck(lastMatch)
1414 :     (* end case *))
1415 : mblume 1912 fun yyQ52 (strm, lastMatch) = (case (yygetc(strm))
1416 : mblume 1902 of NONE => yystuck(lastMatch)
1417 :     | SOME(inp, strm') =>
1418 : mblume 1912 if inp = #"a"
1419 :     then yyQ53(strm', lastMatch)
1420 : mblume 1902 else yystuck(lastMatch)
1421 :     (* end case *))
1422 : mblume 1912 fun yyQ51 (strm, lastMatch) = (case (yygetc(strm))
1423 : mblume 1902 of NONE => yystuck(lastMatch)
1424 :     | SOME(inp, strm') =>
1425 :     if inp = #"e"
1426 : mblume 1912 then yyQ52(strm', lastMatch)
1427 : mblume 1902 else yystuck(lastMatch)
1428 :     (* end case *))
1429 : mblume 1912 fun yyQ43 (strm, lastMatch) = (case (yygetc(strm))
1430 :     of NONE => yystuck(lastMatch)
1431 : mblume 1902 | SOME(inp, strm') =>
1432 : mblume 1912 if inp = #"g"
1433 :     then yystuck(lastMatch)
1434 :     else if inp < #"g"
1435 :     then if inp = #"b"
1436 :     then yystuck(lastMatch)
1437 :     else if inp < #"b"
1438 :     then if inp = #"&"
1439 :     then yystuck(lastMatch)
1440 :     else if inp < #"&"
1441 :     then if inp = #"%"
1442 :     then yyQ44(strm', lastMatch)
1443 :     else yystuck(lastMatch)
1444 :     else if inp = #"a"
1445 :     then yyQ50(strm', lastMatch)
1446 :     else yystuck(lastMatch)
1447 :     else if inp = #"d"
1448 :     then yystuck(lastMatch)
1449 :     else if inp < #"d"
1450 :     then yyQ49(strm', lastMatch)
1451 :     else if inp = #"f"
1452 :     then yyQ46(strm', lastMatch)
1453 :     else yystuck(lastMatch)
1454 :     else if inp = #"s"
1455 :     then yyQ45(strm', lastMatch)
1456 :     else if inp < #"s"
1457 :     then if inp = #"i"
1458 :     then yystuck(lastMatch)
1459 :     else if inp < #"i"
1460 :     then yyQ51(strm', lastMatch)
1461 :     else if inp = #"r"
1462 :     then yyQ48(strm', lastMatch)
1463 :     else yystuck(lastMatch)
1464 :     else if inp = #"u"
1465 :     then yyQ47(strm', lastMatch)
1466 :     else yystuck(lastMatch)
1467 : mblume 1902 (* end case *))
1468 : mblume 1912 fun yyQ1 (strm, lastMatch) = (case (yygetc(strm))
1469 :     of NONE =>
1470 :     if yyInput.eof(strm)
1471 :     then UserDeclarations.eof(yyarg)
1472 :     else yystuck(lastMatch)
1473 : mblume 1902 | SOME(inp, strm') =>
1474 : mblume 1912 if inp = #"%"
1475 :     then yyQ43(strm', lastMatch)
1476 :     else if inp < #"%"
1477 :     then if inp = #"\r"
1478 :     then yyQ40(strm', lastMatch)
1479 :     else if inp < #"\r"
1480 :     then if inp = #"\t"
1481 :     then yyQ40(strm', lastMatch)
1482 :     else if inp < #"\t"
1483 :     then if yyInput.eof(strm)
1484 :     then UserDeclarations.eof(yyarg)
1485 :     else yystuck(lastMatch)
1486 :     else if inp <= #"\n"
1487 :     then yyQ40(strm', lastMatch)
1488 :     else if yyInput.eof(strm)
1489 :     then UserDeclarations.eof(yyarg)
1490 :     else yystuck(lastMatch)
1491 :     else if inp = #" "
1492 :     then yyQ40(strm', lastMatch)
1493 :     else if yyInput.eof(strm)
1494 :     then UserDeclarations.eof(yyarg)
1495 :     else yystuck(lastMatch)
1496 :     else if inp = #"A"
1497 :     then yyQ42(strm', lastMatch)
1498 : mblume 1902 else if inp < #"A"
1499 : mblume 1912 then if inp = #"="
1500 :     then yyQ41(strm', lastMatch)
1501 :     else if yyInput.eof(strm)
1502 :     then UserDeclarations.eof(yyarg)
1503 :     else yystuck(lastMatch)
1504 :     else if inp = #"a"
1505 :     then yyQ42(strm', lastMatch)
1506 :     else if inp < #"a"
1507 :     then if inp <= #"Z"
1508 :     then yyQ42(strm', lastMatch)
1509 :     else if yyInput.eof(strm)
1510 :     then UserDeclarations.eof(yyarg)
1511 :     else yystuck(lastMatch)
1512 : mblume 1902 else if inp <= #"z"
1513 : mblume 1912 then yyQ42(strm', lastMatch)
1514 :     else if yyInput.eof(strm)
1515 :     then UserDeclarations.eof(yyarg)
1516 :     else yystuck(lastMatch)
1517 : mblume 1902 (* end case *))
1518 : mblume 1912 fun yyQ8 (strm, lastMatch) = yyAction14(strm, yyNO_MATCH)
1519 :     fun yyQ9 (strm, lastMatch) = yyAction14(strm, yyNO_MATCH)
1520 :     fun yyQ10 (strm, lastMatch) = yyAction15(strm, yyNO_MATCH)
1521 :     fun yyQ11 (strm, lastMatch) = yyAction16(strm, yyNO_MATCH)
1522 :     fun yyQ12 (strm, lastMatch) = yyAction17(strm, yyNO_MATCH)
1523 :     fun yyQ13 (strm, lastMatch) = yyAction18(strm, yyNO_MATCH)
1524 :     fun yyQ14 (strm, lastMatch) = yyAction19(strm, yyNO_MATCH)
1525 :     fun yyQ15 (strm, lastMatch) = yyAction20(strm, yyNO_MATCH)
1526 :     fun yyQ16 (strm, lastMatch) = yyAction21(strm, yyNO_MATCH)
1527 :     fun yyQ17 (strm, lastMatch) = yyAction22(strm, yyNO_MATCH)
1528 :     fun yyQ18 (strm, lastMatch) = yyAction23(strm, yyNO_MATCH)
1529 :     fun yyQ19 (strm, lastMatch) = yyAction24(strm, yyNO_MATCH)
1530 :     fun yyQ20 (strm, lastMatch) = yyAction25(strm, yyNO_MATCH)
1531 :     fun yyQ21 (strm, lastMatch) = yyAction26(strm, yyNO_MATCH)
1532 :     fun yyQ22 (strm, lastMatch) = yyAction27(strm, yyNO_MATCH)
1533 :     fun yyQ23 (strm, lastMatch) = yyAction28(strm, yyNO_MATCH)
1534 :     fun yyQ24 (strm, lastMatch) = yyAction30(strm, yyNO_MATCH)
1535 :     fun yyQ29 (strm, lastMatch) = yyAction29(strm, yyNO_MATCH)
1536 :     fun yyQ28 (strm, lastMatch) = (case (yygetc(strm))
1537 :     of NONE => yystuck(lastMatch)
1538 : mblume 1902 | SOME(inp, strm') =>
1539 : mblume 1912 if inp = #"\^N"
1540 :     then yystuck(lastMatch)
1541 :     else if inp < #"\^N"
1542 :     then if inp = #"\v"
1543 :     then yystuck(lastMatch)
1544 :     else if inp < #"\v"
1545 :     then if inp <= #"\b"
1546 :     then yystuck(lastMatch)
1547 :     else yyQ28(strm', lastMatch)
1548 :     else if inp = #"\r"
1549 :     then yyQ28(strm', lastMatch)
1550 :     else yystuck(lastMatch)
1551 :     else if inp = #"!"
1552 :     then yystuck(lastMatch)
1553 :     else if inp < #"!"
1554 :     then if inp = #" "
1555 :     then yyQ28(strm', lastMatch)
1556 :     else yystuck(lastMatch)
1557 :     else if inp = #"("
1558 :     then yyQ29(strm', lastMatch)
1559 :     else yystuck(lastMatch)
1560 : mblume 1902 (* end case *))
1561 : mblume 1912 fun yyQ27 (strm, lastMatch) = (case (yygetc(strm))
1562 : mblume 1902 of NONE => yyAction44(strm, yyNO_MATCH)
1563 :     | SOME(inp, strm') =>
1564 : mblume 1912 if inp = #">"
1565 :     then yyQ28(strm', yyMATCH(strm, yyAction44, yyNO_MATCH))
1566 : mblume 1902 else yyAction44(strm, yyNO_MATCH)
1567 :     (* end case *))
1568 : mblume 1912 fun yyQ0 (strm, lastMatch) = (case (yygetc(strm))
1569 :     of NONE =>
1570 :     if yyInput.eof(strm)
1571 :     then UserDeclarations.eof(yyarg)
1572 :     else yystuck(lastMatch)
1573 : mblume 1902 | SOME(inp, strm') =>
1574 : mblume 1912 if inp = #","
1575 :     then yyQ25(strm', lastMatch)
1576 :     else if inp < #","
1577 :     then if inp = #"\""
1578 :     then yyQ20(strm', lastMatch)
1579 :     else if inp < #"\""
1580 :     then if inp = #"\r"
1581 :     then yyQ8(strm', lastMatch)
1582 :     else if inp < #"\r"
1583 :     then if inp = #"\n"
1584 :     then yyQ9(strm', lastMatch)
1585 :     else if inp < #"\n"
1586 :     then if inp = #"\t"
1587 :     then yyQ8(strm', lastMatch)
1588 :     else yyQ25(strm', lastMatch)
1589 :     else yyQ25(strm', lastMatch)
1590 :     else if inp = #" "
1591 :     then yyQ8(strm', lastMatch)
1592 :     else yyQ25(strm', lastMatch)
1593 : mblume 1902 else if inp = #"("
1594 : mblume 1912 then yyQ14(strm', lastMatch)
1595 : mblume 1902 else if inp < #"("
1596 : mblume 1912 then if inp = #"$"
1597 :     then yyQ16(strm', lastMatch)
1598 :     else yyQ25(strm', lastMatch)
1599 :     else if inp = #"*"
1600 :     then yyQ11(strm', lastMatch)
1601 :     else if inp = #")"
1602 :     then yyQ15(strm', lastMatch)
1603 :     else yyQ12(strm', lastMatch)
1604 :     else if inp = #"?"
1605 :     then yyQ10(strm', lastMatch)
1606 :     else if inp < #"?"
1607 :     then if inp = #";"
1608 :     then yyQ24(strm', lastMatch)
1609 :     else if inp < #";"
1610 :     then if inp = #"/"
1611 :     then yyQ17(strm', lastMatch)
1612 :     else if inp < #"/"
1613 :     then if inp = #"."
1614 :     then yyQ18(strm', lastMatch)
1615 :     else yyQ25(strm', lastMatch)
1616 :     else yyQ25(strm', lastMatch)
1617 :     else if inp = #"="
1618 :     then yyQ27(strm', lastMatch)
1619 :     else if inp = #"<"
1620 :     then yyQ22(strm', lastMatch)
1621 :     else yyQ23(strm', lastMatch)
1622 :     else if inp = #"{"
1623 :     then yyQ19(strm', lastMatch)
1624 :     else if inp < #"{"
1625 : mblume 1902 then if inp = #"\\"
1626 : mblume 1912 then yyQ26(strm', lastMatch)
1627 :     else if inp < #"\\"
1628 :     then if inp = #"["
1629 :     then yyQ21(strm', lastMatch)
1630 :     else yyQ25(strm', lastMatch)
1631 :     else yyQ25(strm', lastMatch)
1632 :     else if inp = #"}"
1633 :     then yyQ25(strm', lastMatch)
1634 :     else if inp < #"}"
1635 :     then yyQ13(strm', lastMatch)
1636 : mblume 1902 else if inp <= #"\127"
1637 : mblume 1912 then yyQ25(strm', lastMatch)
1638 :     else if yyInput.eof(strm)
1639 :     then UserDeclarations.eof(yyarg)
1640 : mblume 1902 else yystuck(lastMatch)
1641 :     (* end case *))
1642 :     in
1643 :     (case (!(yyss))
1644 :     of RE => yyQ0(!(yystrm), yyNO_MATCH)
1645 :     | DEFS => yyQ1(!(yystrm), yyNO_MATCH)
1646 :     | RECB => yyQ2(!(yystrm), yyNO_MATCH)
1647 :     | STRING => yyQ3(!(yystrm), yyNO_MATCH)
1648 :     | CHARCLASS => yyQ4(!(yystrm), yyNO_MATCH)
1649 :     | LEXSTATES => yyQ5(!(yystrm), yyNO_MATCH)
1650 :     | ACTION => yyQ6(!(yystrm), yyNO_MATCH)
1651 :     | INITIAL => yyQ7(!(yystrm), yyNO_MATCH)
1652 :     (* end case *))
1653 :     end
1654 :     in continue() end
1655 :     in
1656 :     lex
1657 :     end
1658 :     in
1659 :     fun makeLexer yyinputN = mk (yyInput.mkStream yyinputN)
1660 :     fun makeLexer' ins = mk (yyInput.mkStream ins)
1661 :     end
1662 :    
1663 :     end

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