1 /* A lexical scanner generated by flex */
2
3 /* Scanner skeleton version:
4 * $Header: /projects/higgs1/SNNS/CVS/SNNS/kernel/sources/kr_pat_scan.c,v 2.7 1998/04/08 09:16:54 vogtm Exp $
5 */
6
7 #define FLEX_SCANNER
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
10
11 #include <stdio.h>
12
13
14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
15 #ifdef c_plusplus
16 #ifndef __cplusplus
17 #define __cplusplus
18 #endif
19 #endif
20
21
22 #ifdef __cplusplus
23
24 #include <stdlib.h>
25 #include <unistd.h>
26
27 /* Use prototypes in function declarations. */
28 #define YY_USE_PROTOS
29
30 /* The "const" storage-class-modifier is valid. */
31 #define YY_USE_CONST
32
33 #else /* ! __cplusplus */
34
35 #if __STDC__
36
37 #define YY_USE_PROTOS
38 #define YY_USE_CONST
39
40 #endif /* __STDC__ */
41 #endif /* ! __cplusplus */
42
43 #ifdef __TURBOC__
44 #pragma warn -rch
45 #pragma warn -use
46 #include <io.h>
47 #include <stdlib.h>
48 #define YY_USE_CONST
49 #define YY_USE_PROTOS
50 #endif
51
52 #ifdef YY_USE_CONST
53 #define yyconst const
54 #else
55 #define yyconst
56 #endif
57
58
59 #ifdef YY_USE_PROTOS
60 #define YY_PROTO(proto) proto
61 #else
62 #define YY_PROTO(proto) ()
63 #endif
64
65 /* Returned upon end-of-file. */
66 #define YY_NULL 0
67
68 /* Promotes a possibly negative, possibly signed char to an unsigned
69 * integer for use as an array index. If the signed char is negative,
70 * we want to instead treat it as an 8-bit unsigned char, hence the
71 * double cast.
72 */
73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
74
75 /* Enter a start condition. This macro really ought to take a parameter,
76 * but we do it the disgusting crufty way forced on us by the ()-less
77 * definition of BEGIN.
78 */
79 #define BEGIN yy_start = 1 + 2 *
80
81 /* Translate the current start state into a value that can be later handed
82 * to BEGIN to return to the state. The YYSTATE alias is for lex
83 * compatibility.
84 */
85 #define YY_START ((yy_start - 1) / 2)
86 #define YYSTATE YY_START
87
88 /* Action number for EOF rule of a given start state. */
89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
90
91 /* Special action meaning "start processing a new file". */
92 #define YY_NEW_FILE yyrestart( yyin )
93
94 #define YY_END_OF_BUFFER_CHAR 0
95
96 /* Size of default input buffer. */
97 #define YY_BUF_SIZE 16384
98
99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
100
101 extern int yyleng;
102 extern FILE *yyin, *yyout;
103
104 #define EOB_ACT_CONTINUE_SCAN 0
105 #define EOB_ACT_END_OF_FILE 1
106 #define EOB_ACT_LAST_MATCH 2
107
108 /* The funky do-while in the following #define is used to turn the definition
109 * int a single C statement (which needs a semi-colon terminator). This
110 * avoids problems with code like:
111 *
112 * if ( condition_holds )
113 * yyless( 5 );
114 * else
115 * do_something_else();
116 *
117 * Prior to using the do-while the compiler would get upset at the
118 * "else" because it interpreted the "if" statement as being all
119 * done when it reached the ';' after the yyless() call.
120 */
121
122 /* Return all but the first 'n' matched characters back to the input stream. */
123
124 #define yyless(n) \
125 do \
126 { \
127 /* Undo effects of setting up yytext. */ \
128 *yy_cp = yy_hold_char; \
129 YY_RESTORE_YY_MORE_OFFSET \
130 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
131 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
132 } \
133 while ( 0 )
134
135 #define unput(c) yyunput( c, yytext_ptr )
136
137 /* The following is because we cannot portably get our hands on size_t
138 * (without autoconf's help, which isn't available because we want
139 * flex-generated scanners to compile on their own).
140 */
141 typedef unsigned int yy_size_t;
142
143
144 struct yy_buffer_state
145 {
146 FILE *yy_input_file;
147
148 char *yy_ch_buf; /* input buffer */
149 char *yy_buf_pos; /* current position in input buffer */
150
151 /* Size of input buffer in bytes, not including room for EOB
152 * characters.
153 */
154 yy_size_t yy_buf_size;
155
156 /* Number of characters read into yy_ch_buf, not including EOB
157 * characters.
158 */
159 int yy_n_chars;
160
161 /* Whether we "own" the buffer - i.e., we know we created it,
162 * and can realloc() it to grow it, and should free() it to
163 * delete it.
164 */
165 int yy_is_our_buffer;
166
167 /* Whether this is an "interactive" input source; if so, and
168 * if we're using stdio for input, then we want to use getc()
169 * instead of fread(), to make sure we stop fetching input after
170 * each newline.
171 */
172 int yy_is_interactive;
173
174 /* Whether we're considered to be at the beginning of a line.
175 * If so, '^' rules will be active on the next match, otherwise
176 * not.
177 */
178 int yy_at_bol;
179
180 /* Whether to try to fill the input buffer when we reach the
181 * end of it.
182 */
183 int yy_fill_buffer;
184
185 int yy_buffer_status;
186 #define YY_BUFFER_NEW 0
187 #define YY_BUFFER_NORMAL 1
188 /* When an EOF's been seen but there's still some text to process
189 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
190 * shouldn't try reading from the input source any more. We might
191 * still have a bunch of tokens to match, though, because of
192 * possible backing-up.
193 *
194 * When we actually see the EOF, we change the status to "new"
195 * (via yyrestart()), so that the user can continue scanning by
196 * just pointing yyin at a new input file.
197 */
198 #define YY_BUFFER_EOF_PENDING 2
199 };
200
201 static YY_BUFFER_STATE yy_current_buffer = 0;
202
203 /* We provide macros for accessing buffer states in case in the
204 * future we want to put the buffer states in a more general
205 * "scanner state".
206 */
207 #define YY_CURRENT_BUFFER yy_current_buffer
208
209
210 /* yy_hold_char holds the character lost when yytext is formed. */
211 static char yy_hold_char;
212
213 static int yy_n_chars; /* number of characters read into yy_ch_buf */
214
215
216 int yyleng;
217
218 /* Points to current character in buffer. */
219 static char *yy_c_buf_p = (char *) 0;
220 static int yy_init = 1; /* whether we need to initialize */
221 static int yy_start = 0; /* start state number */
222
223 /* Flag which is used to allow yywrap()'s to do buffer switches
224 * instead of setting up a fresh yyin. A bit of a hack ...
225 */
226 static int yy_did_buffer_switch_on_eof;
227
228 void yyrestart YY_PROTO(( FILE *input_file ));
229
230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
231 void yy_load_buffer_state YY_PROTO(( void ));
232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
237
238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
241
242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
244 static void yy_flex_free YY_PROTO(( void * ));
245
246 #define yy_new_buffer yy_create_buffer
247
248 #define yy_set_interactive(is_interactive) \
249 { \
250 if ( ! yy_current_buffer ) \
251 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
252 yy_current_buffer->yy_is_interactive = is_interactive; \
253 }
254
255 #define yy_set_bol(at_bol) \
256 { \
257 if ( ! yy_current_buffer ) \
258 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
259 yy_current_buffer->yy_at_bol = at_bol; \
260 }
261
262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
263
264 typedef unsigned char YY_CHAR;
265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
266 typedef int yy_state_type;
267 extern char *yytext;
268 #define yytext_ptr yytext
269
270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
272 static int yy_get_next_buffer YY_PROTO(( void ));
273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
274
275 /* Done after the current pattern has been matched and before the
276 * corresponding action - sets up yytext.
277 */
278 #define YY_DO_BEFORE_ACTION \
279 yytext_ptr = yy_bp; \
280 yyleng = (int) (yy_cp - yy_bp); \
281 yy_hold_char = *yy_cp; \
282 *yy_cp = '\0'; \
283 yy_c_buf_p = yy_cp;
284
285 #define YY_NUM_RULES 29
286 #define YY_END_OF_BUFFER 30
287 static yyconst short int yy_accept[284] =
288 { 0,
289 2, 2, 30, 27, 2, 5, 4, 6, 1, 27,
290 27, 10, 27, 27, 27, 27, 27, 27, 7, 8,
291 27, 27, 28, 27, 2, 3, 1, 1, 27, 10,
292 13, 12, 27, 27, 27, 27, 27, 27, 27, 27,
293 27, 12, 27, 27, 11, 27, 27, 27, 27, 27,
294 27, 27, 27, 13, 27, 27, 12, 27, 27, 0,
295 27, 27, 9, 27, 27, 12, 27, 27, 0, 27,
296 0, 9, 27, 0, 27, 0, 0, 0, 9, 9,
297 9, 9, 27, 0, 27, 0, 0, 0, 0, 27,
298 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
299
300 27, 0, 0, 0, 0, 0, 0, 0, 0, 0,
301 0, 0, 27, 0, 0, 0, 0, 0, 0, 0,
302 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
303 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
304 0, 0, 0, 0, 0, 0, 0, 0, 15, 0,
305 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
306 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
307 0, 0, 0, 0, 0, 0, 23, 0, 0, 0,
308 0, 0, 25, 0, 0, 0, 0, 0, 0, 0,
309 0, 16, 0, 0, 0, 0, 0, 0, 0, 0,
310
311 0, 0, 0, 26, 0, 0, 0, 0, 0, 0,
312 0, 0, 0, 0, 0, 0, 0, 17, 0, 0,
313 0, 0, 0, 0, 0, 0, 18, 0, 0, 0,
314 0, 24, 0, 0, 0, 0, 0, 0, 0, 0,
315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
316 0, 0, 0, 21, 0, 0, 0, 0, 0, 22,
317 0, 0, 0, 0, 0, 0, 0, 0, 14, 0,
318 0, 0, 0, 0, 0, 0, 0, 0, 19, 0,
319 0, 20, 0
320 } ;
321
322 static yyconst int yy_ec[256] =
323 { 0,
324 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
325 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
326 1, 1, 1, 1, 1, 5, 1, 1, 1, 1,
327 1, 6, 1, 1, 7, 1, 1, 1, 1, 1,
328 1, 1, 8, 1, 9, 10, 1, 11, 11, 11,
329 11, 11, 11, 11, 11, 11, 11, 12, 1, 1,
330 1, 1, 1, 1, 1, 1, 13, 1, 14, 1,
331 1, 1, 1, 1, 1, 1, 15, 16, 1, 1,
332 1, 17, 18, 1, 1, 19, 1, 1, 1, 1,
333 20, 1, 21, 1, 1, 1, 22, 23, 24, 25,
334
335 26, 27, 28, 1, 29, 1, 1, 30, 31, 32,
336 33, 34, 1, 35, 36, 37, 38, 39, 1, 40,
337 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
339 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
340 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
341 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
342 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
343 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
344 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
345
346 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
347 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
351 1, 1, 1, 1, 1
352 } ;
353
354 static yyconst int yy_meta[41] =
355 { 0,
356 1, 2, 3, 4, 5, 2, 6, 1, 1, 1,
357 1, 1, 1, 1, 1, 1, 1, 1, 1, 7,
358 7, 1, 1, 1, 1, 1, 1, 1, 1, 1,
359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
360 } ;
361
362 static yyconst short int yy_base[294] =
363 { 0,
364 0, 0, 633, 37, 40, 634, 629, 634, 41, 44,
365 49, 67, 59, 78, 87, 91, 99, 108, 0, 0,
366 113, 118, 628, 0, 66, 634, 110, 0, 126, 0,
367 131, 136, 145, 150, 155, 163, 168, 174, 182, 187,
368 195, 200, 214, 206, 219, 224, 232, 238, 243, 245,
369 256, 262, 264, 269, 283, 275, 288, 293, 301, 597,
370 307, 314, 325, 312, 332, 334, 343, 345, 602, 356,
371 594, 370, 370, 592, 375, 620, 25, 603, 391, 0,
372 398, 90, 399, 598, 416, 399, 585, 600, 584, 429,
373 595, 57, 589, 586, 579, 594, 593, 582, 578, 575,
374
375 434, 582, 578, 571, 586, 573, 569, 568, 569, 579,
376 580, 575, 440, 564, 563, 559, 559, 552, 555, 551,
377 554, 544, 545, 540, 552, 532, 529, 528, 525, 523,
378 518, 529, 532, 524, 526, 516, 509, 507, 502, 497,
379 507, 526, 492, 493, 503, 492, 486, 512, 0, 486,
380 504, 470, 466, 461, 488, 459, 456, 451, 452, 450,
381 0, 447, 442, 452, 225, 417, 409, 401, 408, 275,
382 394, 398, 383, 391, 392, 294, 634, 387, 383, 429,
383 408, 450, 634, 372, 380, 368, 372, 370, 357, 359,
384 451, 634, 134, 459, 358, 350, 352, 344, 337, 331,
385
386 333, 326, 462, 634, 331, 328, 320, 324, 467, 301,
387 297, 293, 287, 281, 274, 276, 470, 634, 475, 267,
388 250, 231, 478, 233, 215, 483, 634, 210, 203, 210,
389 486, 634, 203, 189, 209, 175, 174, 170, 158, 162,
390 180, 151, 144, 143, 141, 143, 152, 491, 115, 118,
391 119, 116, 494, 634, 499, 112, 104, 104, 502, 634,
392 94, 95, 81, 70, 72, 77, 66, 48, 634, 50,
393 47, 43, 40, 31, 18, 507, 13, 510, 634, 515,
394 518, 634, 634, 530, 537, 543, 550, 557, 564, 571,
395 578, 585, 592
396
397 } ;
398
399 static yyconst short int yy_def[294] =
400 { 0,
401 283, 1, 283, 284, 283, 283, 285, 283, 286, 284,
402 284, 284, 284, 284, 284, 12, 12, 12, 287, 287,
403 12, 12, 285, 287, 283, 283, 286, 288, 12, 12,
404 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
405 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
406 12, 12, 12, 12, 12, 12, 12, 12, 12, 283,
407 12, 12, 12, 12, 12, 12, 12, 12, 283, 12,
408 283, 289, 12, 283, 12, 283, 283, 283, 289, 290,
409 291, 292, 12, 283, 12, 283, 283, 283, 283, 12,
410 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
411
412 12, 283, 283, 283, 283, 283, 283, 283, 283, 283,
413 283, 283, 12, 283, 283, 283, 283, 283, 283, 283,
414 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
415 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
416 283, 283, 283, 283, 283, 283, 283, 283, 293, 283,
417 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
418 293, 283, 283, 283, 283, 283, 283, 283, 283, 283,
419 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
420 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
421 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
422
423 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
424 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
425 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
426 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
427 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
428 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
429 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
430 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
431 283, 283, 0, 283, 283, 283, 283, 283, 283, 283,
432 283, 283, 283
433
434 } ;
435
436 static yyconst short int yy_nxt[675] =
437 { 0,
438 4, 5, 6, 7, 8, 5, 9, 10, 10, 11,
439 12, 4, 13, 4, 14, 15, 16, 17, 18, 19,
440 20, 4, 4, 4, 4, 4, 4, 21, 4, 4,
441 4, 4, 4, 4, 4, 4, 4, 4, 18, 4,
442 23, 25, 28, 23, 23, 25, 28, 23, 280, 277,
443 23, 87, 23, 29, 30, 23, 24, 24, 88, 31,
444 28, 28, 23, 24, 24, 23, 276, 25, 24, 24,
445 23, 25, 275, 23, 274, 273, 32, 30, 24, 24,
446 33, 23, 272, 271, 23, 103, 24, 24, 34, 104,
447 23, 80, 33, 23, 270, 80, 80, 24, 24, 35,
448
449 22, 22, 269, 268, 22, 267, 24, 24, 22, 22,
450 266, 28, 22, 23, 38, 28, 37, 22, 39, 36,
451 265, 22, 22, 22, 22, 264, 22, 22, 22, 28,
452 28, 22, 263, 22, 262, 22, 31, 261, 40, 22,
453 22, 31, 258, 22, 41, 22, 42, 257, 256, 43,
454 255, 22, 44, 44, 22, 45, 41, 252, 22, 22,
455 22, 43, 201, 22, 22, 22, 202, 251, 22, 250,
456 22, 46, 48, 22, 249, 22, 22, 22, 22, 248,
457 22, 22, 247, 22, 22, 246, 245, 22, 22, 50,
458 244, 51, 39, 22, 47, 22, 22, 22, 49, 22,
459
460 22, 243, 53, 53, 22, 54, 242, 22, 22, 22,
461 42, 241, 22, 55, 240, 22, 45, 239, 52, 22,
462 22, 56, 56, 22, 57, 55, 176, 22, 22, 45,
463 176, 22, 22, 22, 22, 238, 177, 22, 237, 22,
464 236, 22, 22, 60, 22, 22, 235, 22, 22, 22,
465 234, 22, 22, 22, 22, 22, 22, 22, 22, 58,
466 59, 233, 62, 22, 61, 22, 63, 230, 22, 22,
467 22, 22, 22, 22, 54, 22, 182, 22, 22, 54,
468 182, 22, 22, 229, 22, 57, 183, 64, 22, 22,
469 65, 65, 22, 66, 22, 176, 22, 22, 57, 176,
470
471 22, 22, 22, 22, 228, 177, 22, 225, 22, 224,
472 22, 22, 223, 22, 22, 222, 22, 22, 22, 71,
473 22, 22, 22, 22, 22, 22, 22, 22, 67, 221,
474 220, 68, 22, 72, 22, 63, 219, 22, 22, 22,
475 70, 22, 66, 22, 66, 22, 73, 22, 74, 216,
476 22, 215, 22, 22, 22, 22, 22, 22, 22, 22,
477 214, 77, 213, 212, 211, 22, 22, 210, 22, 22,
478 22, 80, 209, 23, 208, 80, 81, 207, 206, 22,
479 22, 22, 75, 22, 22, 22, 205, 200, 22, 82,
480 82, 83, 80, 199, 23, 22, 80, 81, 198, 80,
481
482 22, 23, 197, 80, 196, 85, 195, 194, 22, 22,
483 82, 82, 22, 193, 190, 189, 188, 80, 80, 187,
484 186, 92, 93, 185, 22, 22, 22, 94, 184, 22,
485 191, 95, 96, 181, 191, 90, 180, 97, 22, 22,
486 192, 22, 22, 22, 22, 125, 179, 22, 178, 22,
487 22, 182, 191, 22, 101, 182, 191, 175, 113, 22,
488 203, 183, 192, 203, 203, 22, 174, 203, 217, 173,
489 204, 217, 217, 204, 172, 217, 226, 171, 218, 231,
490 226, 218, 170, 231, 226, 169, 227, 231, 226, 232,
491 168, 231, 253, 167, 227, 253, 253, 232, 166, 253,
492
493 259, 165, 254, 259, 259, 254, 164, 259, 278, 163,
494 260, 278, 278, 260, 162, 278, 281, 160, 279, 281,
495 281, 279, 159, 281, 158, 157, 282, 156, 155, 282,
496 22, 154, 153, 22, 152, 22, 22, 23, 151, 23,
497 23, 150, 23, 27, 27, 149, 27, 148, 27, 27,
498 24, 147, 146, 145, 144, 143, 24, 28, 28, 142,
499 141, 140, 28, 28, 79, 79, 139, 79, 138, 79,
500 79, 80, 80, 137, 136, 135, 80, 80, 81, 81,
501 134, 81, 133, 81, 81, 82, 82, 132, 131, 130,
502 82, 82, 161, 161, 129, 128, 127, 161, 161, 126,
503
504 124, 123, 122, 121, 120, 119, 118, 117, 116, 115,
505 114, 112, 111, 110, 109, 108, 107, 106, 105, 102,
506 100, 99, 98, 91, 89, 86, 84, 78, 76, 69,
507 283, 26, 283, 3, 283, 283, 283, 283, 283, 283,
508 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
509 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
510 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
511 283, 283, 283, 283
512 } ;
513
514 static yyconst short int yy_chk[675] =
515 { 0,
516 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
517 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
518 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
519 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
520 4, 5, 9, 4, 9, 5, 9, 10, 277, 275,
521 10, 77, 11, 10, 10, 11, 4, 4, 77, 11,
522 9, 9, 13, 10, 10, 13, 274, 25, 11, 11,
523 12, 25, 273, 12, 272, 271, 12, 12, 13, 13,
524 12, 14, 270, 268, 14, 92, 12, 12, 13, 92,
525 15, 82, 12, 15, 267, 82, 82, 14, 14, 14,
526
527 16, 16, 266, 265, 16, 264, 15, 15, 17, 17,
528 263, 27, 17, 27, 17, 27, 16, 18, 18, 15,
529 262, 18, 21, 21, 17, 261, 21, 22, 22, 27,
530 27, 22, 258, 18, 257, 29, 29, 256, 21, 29,
531 31, 31, 252, 22, 31, 32, 32, 251, 250, 32,
532 249, 29, 33, 33, 33, 33, 31, 247, 33, 34,
533 34, 32, 193, 34, 35, 35, 193, 246, 35, 245,
534 33, 34, 36, 36, 244, 34, 36, 37, 37, 243,
535 35, 37, 242, 38, 38, 241, 240, 38, 36, 38,
536 239, 39, 39, 37, 35, 39, 40, 40, 37, 38,
537
538 40, 238, 41, 41, 41, 41, 237, 39, 41, 42,
539 42, 236, 40, 42, 235, 44, 44, 234, 40, 44,
540 41, 43, 43, 43, 43, 42, 165, 43, 45, 45,
541 165, 44, 45, 46, 46, 233, 165, 46, 230, 43,
542 229, 47, 47, 48, 45, 47, 228, 48, 48, 46,
543 225, 48, 49, 49, 50, 50, 49, 47, 50, 46,
544 47, 224, 50, 48, 49, 51, 51, 222, 49, 51,
545 50, 52, 52, 53, 53, 52, 170, 53, 54, 54,
546 170, 51, 54, 221, 56, 56, 170, 52, 56, 53,
547 55, 55, 55, 55, 54, 176, 55, 57, 57, 176,
548
549 56, 57, 58, 58, 220, 176, 58, 216, 55, 215,
550 59, 59, 214, 57, 59, 213, 61, 61, 58, 62,
551 61, 64, 64, 62, 62, 64, 59, 62, 58, 212,
552 211, 59, 61, 63, 63, 63, 210, 64, 63, 62,
553 61, 65, 65, 66, 66, 65, 64, 66, 67, 208,
554 63, 207, 67, 67, 68, 68, 67, 65, 68, 66,
555 206, 70, 205, 202, 201, 70, 70, 200, 67, 70,
556 68, 72, 199, 72, 198, 72, 72, 197, 196, 73,
557 73, 70, 68, 73, 75, 75, 195, 190, 75, 72,
558 72, 73, 79, 189, 79, 73, 79, 79, 188, 81,
559
560 75, 81, 187, 81, 186, 75, 185, 184, 83, 83,
561 79, 79, 83, 181, 179, 178, 175, 81, 81, 174,
562 173, 85, 86, 172, 83, 85, 85, 86, 171, 85,
563 180, 86, 86, 169, 180, 83, 168, 86, 90, 90,
564 180, 85, 90, 101, 101, 113, 167, 101, 166, 113,
565 113, 182, 191, 113, 90, 182, 191, 164, 101, 101,
566 194, 182, 191, 203, 194, 113, 163, 203, 209, 162,
567 194, 217, 209, 203, 160, 217, 219, 159, 209, 223,
568 219, 217, 158, 223, 226, 157, 219, 231, 226, 223,
569 156, 231, 248, 155, 226, 253, 248, 231, 154, 253,
570
571 255, 153, 248, 259, 255, 253, 152, 259, 276, 151,
572 255, 278, 276, 259, 150, 278, 280, 148, 276, 281,
573 280, 278, 147, 281, 146, 145, 280, 144, 143, 281,
574 284, 142, 141, 284, 140, 284, 284, 285, 139, 285,
575 285, 138, 285, 286, 286, 137, 286, 136, 286, 286,
576 287, 135, 134, 133, 132, 131, 287, 288, 288, 130,
577 129, 128, 288, 288, 289, 289, 127, 289, 126, 289,
578 289, 290, 290, 125, 124, 123, 290, 290, 291, 291,
579 122, 291, 121, 291, 291, 292, 292, 120, 119, 118,
580 292, 292, 293, 293, 117, 116, 115, 293, 293, 114,
581
582 112, 111, 110, 109, 108, 107, 106, 105, 104, 103,
583 102, 100, 99, 98, 97, 96, 95, 94, 93, 91,
584 89, 88, 87, 84, 78, 76, 74, 71, 69, 60,
585 23, 7, 3, 283, 283, 283, 283, 283, 283, 283,
586 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
587 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
588 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
589 283, 283, 283, 283
590 } ;
591
592 static yy_state_type yy_last_accepting_state;
593 static char *yy_last_accepting_cpos;
594
595 /* The intent behind this definition is that it'll catch
596 * any uses of REJECT which flex missed.
597 */
598 #define REJECT reject_used_but_not_detected
599 #define yymore() yymore_used_but_not_detected
600 #define YY_MORE_ADJ 0
601 #define YY_RESTORE_YY_MORE_OFFSET
602 char *yytext;
603 #line 1 "kr_pat_scan.l"
604 #define INITIAL 0
605 #line 2 "kr_pat_scan.l"
606 /*****************************************************************************
607 FILE : $Source: /projects/higgs1/SNNS/CVS/SNNS/kernel/sources/kr_pat_scan.c,v $
608 SHORTNAME : pattern scanner
609 SNNS VERSION : 4.2
610
611 PURPOSE : pattern file scanner, lex file
612 NOTES : preliminary
613
614 AUTHOR : Michael Vogt
615 DATE : 10.9.93
616
617 CHANGED BY :
618 RCS VERSION : $Revision: 2.7 $
619 LAST CHANGE : $Date: 1998/04/08 09:16:54 $
620
621 Copyright (c) 1990-1998 SNNS Group, IPVR, Univ. Stuttgart, Germany
622
623 ******************************************************************************/
624
625 #include "y.tab.h"
626 #include <stdlib.h>
627 #include <string.h>
628 #include "glob_typ.h"
629 #include "kr_typ.h"
630 #include "kernel.h"
631 #include "kr_newpattern.h"
632 #include "kr_pat_parse.h"
633 #include "kr_pat_scan.ph"
634
635 #line 653 "lex.yy.c"
636
637 /* Macros after this point can all be overridden by user definitions in
638 * section 1.
639 */
640
641 #ifndef YY_SKIP_YYWRAP
642 #ifdef __cplusplus
643 extern "C" int yywrap YY_PROTO(( void ));
644 #else
645 extern int yywrap YY_PROTO(( void ));
646 #endif
647 #endif
648
649 #ifndef YY_NO_UNPUT
650 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
651 #endif
652
653 #ifndef yytext_ptr
654 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
655 #endif
656
657 #ifdef YY_NEED_STRLEN
658 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
659 #endif
660
661 #ifndef YY_NO_INPUT
662 #ifdef __cplusplus
663 static int yyinput YY_PROTO(( void ));
664 #else
665 static int input YY_PROTO(( void ));
666 #endif
667 #endif
668
669 #if YY_STACK_USED
670 static int yy_start_stack_ptr = 0;
671 static int yy_start_stack_depth = 0;
672 static int *yy_start_stack = 0;
673 #ifndef YY_NO_PUSH_STATE
674 static void yy_push_state YY_PROTO(( int new_state ));
675 #endif
676 #ifndef YY_NO_POP_STATE
677 static void yy_pop_state YY_PROTO(( void ));
678 #endif
679 #ifndef YY_NO_TOP_STATE
680 static int yy_top_state YY_PROTO(( void ));
681 #endif
682
683 #else
684 #define YY_NO_PUSH_STATE 1
685 #define YY_NO_POP_STATE 1
686 #define YY_NO_TOP_STATE 1
687 #endif
688
689 #ifdef YY_MALLOC_DECL
690 YY_MALLOC_DECL
691 #else
692 #if __STDC__
693 #ifndef __cplusplus
694 #include <stdlib.h>
695 #endif
696 #else
697 /* Just try to get by without declaring the routines. This will fail
698 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
699 * or sizeof(void*) != sizeof(int).
700 */
701 #endif
702 #endif
703
704 /* Amount of stuff to slurp up with each read. */
705 #ifndef YY_READ_BUF_SIZE
706 #define YY_READ_BUF_SIZE 8192
707 #endif
708
709 /* Copy whatever the last rule matched to the standard output. */
710
711 #ifndef ECHO
712 /* This used to be an fputs(), but since the string might contain NUL's,
713 * we now use fwrite().
714 */
715 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
716 #endif
717
718 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
719 * is returned in "result".
720 */
721 #ifndef YY_INPUT
722 #define YY_INPUT(buf,result,max_size) \
723 if ( yy_current_buffer->yy_is_interactive ) \
724 { \
725 int c = '*', n; \
726 for ( n = 0; n < max_size && \
727 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
728 buf[n] = (char) c; \
729 if ( c == '\n' ) \
730 buf[n++] = (char) c; \
731 if ( c == EOF && ferror( yyin ) ) \
732 YY_FATAL_ERROR( "input in flex scanner failed" ); \
733 result = n; \
734 } \
735 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
736 && ferror( yyin ) ) \
737 YY_FATAL_ERROR( "input in flex scanner failed" );
738 #endif
739
740 /* No semi-colon after return; correct usage is to write "yyterminate();" -
741 * we don't want an extra ';' after the "return" because that will cause
742 * some compilers to complain about unreachable statements.
743 */
744 #ifndef yyterminate
745 #define yyterminate() return YY_NULL
746 #endif
747
748 /* Number of entries by which start-condition stack grows. */
749 #ifndef YY_START_STACK_INCR
750 #define YY_START_STACK_INCR 25
751 #endif
752
753 /* Report a fatal error. */
754 #ifndef YY_FATAL_ERROR
755 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
756 #endif
757
758 /* Default declaration of generated scanner - a define so the user can
759 * easily add parameters.
760 */
761 #ifndef YY_DECL
762 #define YY_DECL int yylex YY_PROTO(( void ))
763 #endif
764
765 /* Code executed at the beginning of each rule, after yytext and yyleng
766 * have been set up.
767 */
768 #ifndef YY_USER_ACTION
769 #define YY_USER_ACTION
770 #endif
771
772 /* Code executed at the end of each rule. */
773 #ifndef YY_BREAK
774 #define YY_BREAK break;
775 #endif
776
777 #define YY_RULE_SETUP \
778 YY_USER_ACTION
779
780 YY_DECL
781 {
782 register yy_state_type yy_current_state;
783 register char *yy_cp, *yy_bp;
784 register int yy_act;
785
786 #line 56 "kr_pat_scan.l"
787
788
789 #line 807 "lex.yy.c"
790
791 if ( yy_init )
792 {
793 yy_init = 0;
794
795 #ifdef YY_USER_INIT
796 YY_USER_INIT;
797 #endif
798
799 if ( ! yy_start )
800 yy_start = 1; /* first start state */
801
802 if ( ! yyin )
803 yyin = stdin;
804
805 if ( ! yyout )
806 yyout = stdout;
807
808 if ( ! yy_current_buffer )
809 yy_current_buffer =
810 yy_create_buffer( yyin, YY_BUF_SIZE );
811
812 yy_load_buffer_state();
813 }
814
815 while ( 1 ) /* loops until end-of-file is reached */
816 {
817 yy_cp = yy_c_buf_p;
818
819 /* Support of yytext. */
820 *yy_cp = yy_hold_char;
821
822 /* yy_bp points to the position in yy_ch_buf of the start of
823 * the current run.
824 */
825 yy_bp = yy_cp;
826
827 yy_current_state = yy_start;
828 yy_match:
829 do
830 {
831 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
832 if ( yy_accept[yy_current_state] )
833 {
834 yy_last_accepting_state = yy_current_state;
835 yy_last_accepting_cpos = yy_cp;
836 }
837 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
838 {
839 yy_current_state = (int) yy_def[yy_current_state];
840 if ( yy_current_state >= 284 )
841 yy_c = yy_meta[(unsigned int) yy_c];
842 }
843 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
844 ++yy_cp;
845 }
846 while ( yy_base[yy_current_state] != 634 );
847
848 yy_find_action:
849 yy_act = yy_accept[yy_current_state];
850 if ( yy_act == 0 )
851 { /* have to back up */
852 yy_cp = yy_last_accepting_cpos;
853 yy_current_state = yy_last_accepting_state;
854 yy_act = yy_accept[yy_current_state];
855 }
856
857 YY_DO_BEFORE_ACTION;
858
859
860 do_action: /* This label is used only to access EOF actions. */
861
862
863 switch ( yy_act )
864 { /* beginning of action switch */
865 case 0: /* must back up */
866 /* undo the effects of YY_DO_BEFORE_ACTION */
867 *yy_cp = yy_hold_char;
868 yy_cp = yy_last_accepting_cpos;
869 yy_current_state = yy_last_accepting_state;
870 goto yy_find_action;
871
872 case 1:
873 #line 59 "kr_pat_scan.l"
874 case 2:
875 YY_RULE_SETUP
876 #line 59 "kr_pat_scan.l"
877 ;
878 YY_BREAK
879 case 3:
880 #line 62 "kr_pat_scan.l"
881 case 4:
882 #line 63 "kr_pat_scan.l"
883 case 5:
884 YY_RULE_SETUP
885 #line 63 "kr_pat_scan.l"
886 lineno++;
887 YY_BREAK
888 case 6:
889 YY_RULE_SETUP
890 #line 65 "kr_pat_scan.l"
891 return(0); /* end of text */
892 YY_BREAK
893 case 7:
894 YY_RULE_SETUP
895 #line 67 "kr_pat_scan.l"
896 return(L_BRACKET);
897 YY_BREAK
898 case 8:
899 YY_RULE_SETUP
900 #line 69 "kr_pat_scan.l"
901 return(R_BRACKET);
902 YY_BREAK
903 case 9:
904 YY_RULE_SETUP
905 #line 71 "kr_pat_scan.l"
906 {
907 s_dotpos = strchr((char *) yytext, '.');
908 *s_dotpos = '\0';
909 yylval.version.v =
910 atoi((char *) yytext+1);
911 yylval.version.r =
912 atoi((char *) s_dotpos+1);
913 return(V_NUMBER);
914 }
915 YY_BREAK
916 case 10:
917 #line 82 "kr_pat_scan.l"
918 case 11:
919 #line 83 "kr_pat_scan.l"
920 case 12:
921 #line 84 "kr_pat_scan.l"
922 case 13:
923 YY_RULE_SETUP
924 #line 84 "kr_pat_scan.l"
925 {
926 if (numbers_as_names)
927 {
928 yylval.name = strdup(yytext);
929 return(NAME);
930 }
931 else
932 {
933 yylval.value=atof((char *) yytext);
934 return(NUMBER);
935 }
936 }
937 YY_BREAK
938 case 14:
939 YY_RULE_SETUP
940 #line 97 "kr_pat_scan.l"
941 return(VERSION_HEADER);
942 YY_BREAK
943 case 15:
944 YY_RULE_SETUP
945 #line 99 "kr_pat_scan.l"
946 return(GENERATED_AT);
947 YY_BREAK
948 case 16:
949 YY_RULE_SETUP
950 #line 101 "kr_pat_scan.l"
951 return(NO_OF_PATTERN);
952 YY_BREAK
953 case 17:
954 YY_RULE_SETUP
955 #line 103 "kr_pat_scan.l"
956 return(NO_OF_INPUT);
957 YY_BREAK
958 case 18:
959 YY_RULE_SETUP
960 #line 105 "kr_pat_scan.l"
961 return(NO_OF_OUTPUT);
962 YY_BREAK
963 case 19:
964 YY_RULE_SETUP
965 #line 107 "kr_pat_scan.l"
966 return(NO_OF_VAR_IDIM);
967 YY_BREAK
968 case 20:
969 YY_RULE_SETUP
970 #line 109 "kr_pat_scan.l"
971 return(NO_OF_VAR_ODIM);
972 YY_BREAK
973 case 21:
974 YY_RULE_SETUP
975 #line 111 "kr_pat_scan.l"
976 return(MAXIMUM_IDIM);
977 YY_BREAK
978 case 22:
979 YY_RULE_SETUP
980 #line 113 "kr_pat_scan.l"
981 return(MAXIMUM_ODIM);
982 YY_BREAK
983 case 23:
984 YY_RULE_SETUP
985 #line 115 "kr_pat_scan.l"
986 return(NO_OF_CLASSES);
987 YY_BREAK
988 case 24:
989 YY_RULE_SETUP
990 #line 117 "kr_pat_scan.l"
991 return(CLASS_REDISTRIB);
992 YY_BREAK
993 case 25:
994 YY_RULE_SETUP
995 #line 119 "kr_pat_scan.l"
996 return(REMAPFUNCTION);
997 YY_BREAK
998 case 26:
999 YY_RULE_SETUP
1000 #line 121 "kr_pat_scan.l"
1001 return(REMAP_PARAM);
1002 YY_BREAK
1003 case 27:
1004 YY_RULE_SETUP
1005 #line 123 "kr_pat_scan.l"
1006 {
1007 yylval.name = strdup(yytext);
1008 return(NAME);
1009 }
1010 YY_BREAK
1011 case 28:
1012 YY_RULE_SETUP
1013 #line 128 "kr_pat_scan.l"
1014 return(ERROR);
1015 YY_BREAK
1016 case 29:
1017 YY_RULE_SETUP
1018 #line 130 "kr_pat_scan.l"
1019 ECHO;
1020 YY_BREAK
1021 #line 1039 "lex.yy.c"
1022 case YY_STATE_EOF(INITIAL):
1023 yyterminate();
1024
1025 case YY_END_OF_BUFFER:
1026 {
1027 /* Amount of text matched not including the EOB char. */
1028 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1029
1030 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1031 *yy_cp = yy_hold_char;
1032 YY_RESTORE_YY_MORE_OFFSET
1033
1034 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1035 {
1036 /* We're scanning a new file or input source. It's
1037 * possible that this happened because the user
1038 * just pointed yyin at a new source and called
1039 * yylex(). If so, then we have to assure
1040 * consistency between yy_current_buffer and our
1041 * globals. Here is the right place to do so, because
1042 * this is the first action (other than possibly a
1043 * back-up) that will match for the new input source.
1044 */
1045 yy_n_chars = yy_current_buffer->yy_n_chars;
1046 yy_current_buffer->yy_input_file = yyin;
1047 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1048 }
1049
1050 /* Note that here we test for yy_c_buf_p "<=" to the position
1051 * of the first EOB in the buffer, since yy_c_buf_p will
1052 * already have been incremented past the NUL character
1053 * (since all states make transitions on EOB to the
1054 * end-of-buffer state). Contrast this with the test
1055 * in input().
1056 */
1057 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1058 { /* This was really a NUL. */
1059 yy_state_type yy_next_state;
1060
1061 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1062
1063 yy_current_state = yy_get_previous_state();
1064
1065 /* Okay, we're now positioned to make the NUL
1066 * transition. We couldn't have
1067 * yy_get_previous_state() go ahead and do it
1068 * for us because it doesn't know how to deal
1069 * with the possibility of jamming (and we don't
1070 * want to build jamming into it because then it
1071 * will run more slowly).
1072 */
1073
1074 yy_next_state = yy_try_NUL_trans( yy_current_state );
1075
1076 yy_bp = yytext_ptr + YY_MORE_ADJ;
1077
1078 if ( yy_next_state )
1079 {
1080 /* Consume the NUL. */
1081 yy_cp = ++yy_c_buf_p;
1082 yy_current_state = yy_next_state;
1083 goto yy_match;
1084 }
1085
1086 else
1087 {
1088 yy_cp = yy_c_buf_p;
1089 goto yy_find_action;
1090 }
1091 }
1092
1093 else switch ( yy_get_next_buffer() )
1094 {
1095 case EOB_ACT_END_OF_FILE:
1096 {
1097 yy_did_buffer_switch_on_eof = 0;
1098
1099 if ( yywrap() )
1100 {
1101 /* Note: because we've taken care in
1102 * yy_get_next_buffer() to have set up
1103 * yytext, we can now set up
1104 * yy_c_buf_p so that if some total
1105 * hoser (like flex itself) wants to
1106 * call the scanner after we return the
1107 * YY_NULL, it'll still work - another
1108 * YY_NULL will get returned.
1109 */
1110 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1111
1112 yy_act = YY_STATE_EOF(YY_START);
1113 goto do_action;
1114 }
1115
1116 else
1117 {
1118 if ( ! yy_did_buffer_switch_on_eof )
1119 YY_NEW_FILE;
1120 }
1121 break;
1122 }
1123
1124 case EOB_ACT_CONTINUE_SCAN:
1125 yy_c_buf_p =
1126 yytext_ptr + yy_amount_of_matched_text;
1127
1128 yy_current_state = yy_get_previous_state();
1129
1130 yy_cp = yy_c_buf_p;
1131 yy_bp = yytext_ptr + YY_MORE_ADJ;
1132 goto yy_match;
1133
1134 case EOB_ACT_LAST_MATCH:
1135 yy_c_buf_p =
1136 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1137
1138 yy_current_state = yy_get_previous_state();
1139
1140 yy_cp = yy_c_buf_p;
1141 yy_bp = yytext_ptr + YY_MORE_ADJ;
1142 goto yy_find_action;
1143 }
1144 break;
1145 }
1146
1147 default:
1148 YY_FATAL_ERROR(
1149 "fatal flex scanner internal error--no action found" );
1150 } /* end of action switch */
1151 } /* end of scanning one token */
1152 } /* end of yylex */
1153
1154
1155 /* yy_get_next_buffer - try to read in a new buffer
1156 *
1157 * Returns a code representing an action:
1158 * EOB_ACT_LAST_MATCH -
1159 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1160 * EOB_ACT_END_OF_FILE - end of file
1161 */
1162
yy_get_next_buffer()1163 static int yy_get_next_buffer()
1164 {
1165 register char *dest = yy_current_buffer->yy_ch_buf;
1166 register char *source = yytext_ptr;
1167 register int number_to_move, i;
1168 int ret_val;
1169
1170 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1171 YY_FATAL_ERROR(
1172 "fatal flex scanner internal error--end of buffer missed" );
1173
1174 if ( yy_current_buffer->yy_fill_buffer == 0 )
1175 { /* Don't try to fill the buffer, so this is an EOF. */
1176 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1177 {
1178 /* We matched a single character, the EOB, so
1179 * treat this as a final EOF.
1180 */
1181 return EOB_ACT_END_OF_FILE;
1182 }
1183
1184 else
1185 {
1186 /* We matched some text prior to the EOB, first
1187 * process it.
1188 */
1189 return EOB_ACT_LAST_MATCH;
1190 }
1191 }
1192
1193 /* Try to read more data. */
1194
1195 /* First move last chars to start of buffer. */
1196 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1197
1198 for ( i = 0; i < number_to_move; ++i )
1199 *(dest++) = *(source++);
1200
1201 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1202 /* don't do the read, it's not guaranteed to return an EOF,
1203 * just force an EOF
1204 */
1205 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1206
1207 else
1208 {
1209 int num_to_read =
1210 yy_current_buffer->yy_buf_size - number_to_move - 1;
1211
1212 while ( num_to_read <= 0 )
1213 { /* Not enough room in the buffer - grow it. */
1214 #ifdef YY_USES_REJECT
1215 YY_FATAL_ERROR(
1216 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1217 #else
1218
1219 /* just a shorter name for the current buffer */
1220 YY_BUFFER_STATE b = yy_current_buffer;
1221
1222 int yy_c_buf_p_offset =
1223 (int) (yy_c_buf_p - b->yy_ch_buf);
1224
1225 if ( b->yy_is_our_buffer )
1226 {
1227 int new_size = b->yy_buf_size * 2;
1228
1229 if ( new_size <= 0 )
1230 b->yy_buf_size += b->yy_buf_size / 8;
1231 else
1232 b->yy_buf_size *= 2;
1233
1234 b->yy_ch_buf = (char *)
1235 /* Include room in for 2 EOB chars. */
1236 yy_flex_realloc( (void *) b->yy_ch_buf,
1237 b->yy_buf_size + 2 );
1238 }
1239 else
1240 /* Can't grow it, we don't own it. */
1241 b->yy_ch_buf = 0;
1242
1243 if ( ! b->yy_ch_buf )
1244 YY_FATAL_ERROR(
1245 "fatal error - scanner input buffer overflow" );
1246
1247 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1248
1249 num_to_read = yy_current_buffer->yy_buf_size -
1250 number_to_move - 1;
1251 #endif
1252 }
1253
1254 if ( num_to_read > YY_READ_BUF_SIZE )
1255 num_to_read = YY_READ_BUF_SIZE;
1256
1257 /* Read in more data. */
1258 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1259 yy_n_chars, num_to_read );
1260
1261 yy_current_buffer->yy_n_chars = yy_n_chars;
1262 }
1263
1264 if ( yy_n_chars == 0 )
1265 {
1266 if ( number_to_move == YY_MORE_ADJ )
1267 {
1268 ret_val = EOB_ACT_END_OF_FILE;
1269 yyrestart( yyin );
1270 }
1271
1272 else
1273 {
1274 ret_val = EOB_ACT_LAST_MATCH;
1275 yy_current_buffer->yy_buffer_status =
1276 YY_BUFFER_EOF_PENDING;
1277 }
1278 }
1279
1280 else
1281 ret_val = EOB_ACT_CONTINUE_SCAN;
1282
1283 yy_n_chars += number_to_move;
1284 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1285 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1286
1287 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1288
1289 return ret_val;
1290 }
1291
1292
1293 /* yy_get_previous_state - get the state just before the EOB char was reached */
1294
yy_get_previous_state()1295 static yy_state_type yy_get_previous_state()
1296 {
1297 register yy_state_type yy_current_state;
1298 register char *yy_cp;
1299
1300 yy_current_state = yy_start;
1301
1302 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1303 {
1304 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1305 if ( yy_accept[yy_current_state] )
1306 {
1307 yy_last_accepting_state = yy_current_state;
1308 yy_last_accepting_cpos = yy_cp;
1309 }
1310 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1311 {
1312 yy_current_state = (int) yy_def[yy_current_state];
1313 if ( yy_current_state >= 284 )
1314 yy_c = yy_meta[(unsigned int) yy_c];
1315 }
1316 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1317 }
1318
1319 return yy_current_state;
1320 }
1321
1322
1323 /* yy_try_NUL_trans - try to make a transition on the NUL character
1324 *
1325 * synopsis
1326 * next_state = yy_try_NUL_trans( current_state );
1327 */
1328
1329 #ifdef YY_USE_PROTOS
yy_try_NUL_trans(yy_state_type yy_current_state)1330 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1331 #else
1332 static yy_state_type yy_try_NUL_trans( yy_current_state )
1333 yy_state_type yy_current_state;
1334 #endif
1335 {
1336 register int yy_is_jam;
1337 register char *yy_cp = yy_c_buf_p;
1338
1339 register YY_CHAR yy_c = 1;
1340 if ( yy_accept[yy_current_state] )
1341 {
1342 yy_last_accepting_state = yy_current_state;
1343 yy_last_accepting_cpos = yy_cp;
1344 }
1345 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1346 {
1347 yy_current_state = (int) yy_def[yy_current_state];
1348 if ( yy_current_state >= 284 )
1349 yy_c = yy_meta[(unsigned int) yy_c];
1350 }
1351 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1352 yy_is_jam = (yy_current_state == 283);
1353
1354 return yy_is_jam ? 0 : yy_current_state;
1355 }
1356
1357
1358 #ifndef YY_NO_UNPUT
1359 #ifdef YY_USE_PROTOS
yyunput(int c,register char * yy_bp)1360 static void yyunput( int c, register char *yy_bp )
1361 #else
1362 static void yyunput( c, yy_bp )
1363 int c;
1364 register char *yy_bp;
1365 #endif
1366 {
1367 register char *yy_cp = yy_c_buf_p;
1368
1369 /* undo effects of setting up yytext */
1370 *yy_cp = yy_hold_char;
1371
1372 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1373 { /* need to shift things up to make room */
1374 /* +2 for EOB chars. */
1375 register int number_to_move = yy_n_chars + 2;
1376 register char *dest = &yy_current_buffer->yy_ch_buf[
1377 yy_current_buffer->yy_buf_size + 2];
1378 register char *source =
1379 &yy_current_buffer->yy_ch_buf[number_to_move];
1380
1381 while ( source > yy_current_buffer->yy_ch_buf )
1382 *--dest = *--source;
1383
1384 yy_cp += (int) (dest - source);
1385 yy_bp += (int) (dest - source);
1386 yy_current_buffer->yy_n_chars =
1387 yy_n_chars = yy_current_buffer->yy_buf_size;
1388
1389 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1390 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1391 }
1392
1393 *--yy_cp = (char) c;
1394
1395
1396 yytext_ptr = yy_bp;
1397 yy_hold_char = *yy_cp;
1398 yy_c_buf_p = yy_cp;
1399 }
1400 #endif /* ifndef YY_NO_UNPUT */
1401
1402
1403 #ifdef __cplusplus
yyinput()1404 static int yyinput()
1405 #else
1406 static int input()
1407 #endif
1408 {
1409 int c;
1410
1411 *yy_c_buf_p = yy_hold_char;
1412
1413 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1414 {
1415 /* yy_c_buf_p now points to the character we want to return.
1416 * If this occurs *before* the EOB characters, then it's a
1417 * valid NUL; if not, then we've hit the end of the buffer.
1418 */
1419 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1420 /* This was really a NUL. */
1421 *yy_c_buf_p = '\0';
1422
1423 else
1424 { /* need more input */
1425 int offset = yy_c_buf_p - yytext_ptr;
1426 ++yy_c_buf_p;
1427
1428 switch ( yy_get_next_buffer() )
1429 {
1430 case EOB_ACT_LAST_MATCH:
1431 /* This happens because yy_g_n_b()
1432 * sees that we've accumulated a
1433 * token and flags that we need to
1434 * try matching the token before
1435 * proceeding. But for input(),
1436 * there's no matching to consider.
1437 * So convert the EOB_ACT_LAST_MATCH
1438 * to EOB_ACT_END_OF_FILE.
1439 */
1440
1441 /* Reset buffer status. */
1442 yyrestart( yyin );
1443
1444 /* fall through */
1445
1446 case EOB_ACT_END_OF_FILE:
1447 {
1448 if ( yywrap() )
1449 return EOF;
1450
1451 if ( ! yy_did_buffer_switch_on_eof )
1452 YY_NEW_FILE;
1453 #ifdef __cplusplus
1454 return yyinput();
1455 #else
1456 return input();
1457 #endif
1458 }
1459
1460 case EOB_ACT_CONTINUE_SCAN:
1461 yy_c_buf_p = yytext_ptr + offset;
1462 break;
1463 }
1464 }
1465 }
1466
1467 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1468 *yy_c_buf_p = '\0'; /* preserve yytext */
1469 yy_hold_char = *++yy_c_buf_p;
1470
1471
1472 return c;
1473 }
1474
1475
1476 #ifdef YY_USE_PROTOS
yyrestart(FILE * input_file)1477 void yyrestart( FILE *input_file )
1478 #else
1479 void yyrestart( input_file )
1480 FILE *input_file;
1481 #endif
1482 {
1483 if ( ! yy_current_buffer )
1484 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1485
1486 yy_init_buffer( yy_current_buffer, input_file );
1487 yy_load_buffer_state();
1488 }
1489
1490
1491 #ifdef YY_USE_PROTOS
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)1492 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1493 #else
1494 void yy_switch_to_buffer( new_buffer )
1495 YY_BUFFER_STATE new_buffer;
1496 #endif
1497 {
1498 if ( yy_current_buffer == new_buffer )
1499 return;
1500
1501 if ( yy_current_buffer )
1502 {
1503 /* Flush out information for old buffer. */
1504 *yy_c_buf_p = yy_hold_char;
1505 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1506 yy_current_buffer->yy_n_chars = yy_n_chars;
1507 }
1508
1509 yy_current_buffer = new_buffer;
1510 yy_load_buffer_state();
1511
1512 /* We don't actually know whether we did this switch during
1513 * EOF (yywrap()) processing, but the only time this flag
1514 * is looked at is after yywrap() is called, so it's safe
1515 * to go ahead and always set it.
1516 */
1517 yy_did_buffer_switch_on_eof = 1;
1518 }
1519
1520
1521 #ifdef YY_USE_PROTOS
yy_load_buffer_state(void)1522 void yy_load_buffer_state( void )
1523 #else
1524 void yy_load_buffer_state()
1525 #endif
1526 {
1527 yy_n_chars = yy_current_buffer->yy_n_chars;
1528 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1529 yyin = yy_current_buffer->yy_input_file;
1530 yy_hold_char = *yy_c_buf_p;
1531 }
1532
1533
1534 #ifdef YY_USE_PROTOS
yy_create_buffer(FILE * file,int size)1535 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1536 #else
1537 YY_BUFFER_STATE yy_create_buffer( file, size )
1538 FILE *file;
1539 int size;
1540 #endif
1541 {
1542 YY_BUFFER_STATE b;
1543
1544 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1545 if ( ! b )
1546 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1547
1548 b->yy_buf_size = size;
1549
1550 /* yy_ch_buf has to be 2 characters longer than the size given because
1551 * we need to put in 2 end-of-buffer characters.
1552 */
1553 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1554 if ( ! b->yy_ch_buf )
1555 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1556
1557 b->yy_is_our_buffer = 1;
1558
1559 yy_init_buffer( b, file );
1560
1561 return b;
1562 }
1563
1564
1565 #ifdef YY_USE_PROTOS
yy_delete_buffer(YY_BUFFER_STATE b)1566 void yy_delete_buffer( YY_BUFFER_STATE b )
1567 #else
1568 void yy_delete_buffer( b )
1569 YY_BUFFER_STATE b;
1570 #endif
1571 {
1572 if ( ! b )
1573 return;
1574
1575 if ( b == yy_current_buffer )
1576 yy_current_buffer = (YY_BUFFER_STATE) 0;
1577
1578 if ( b->yy_is_our_buffer )
1579 yy_flex_free( (void *) b->yy_ch_buf );
1580
1581 yy_flex_free( (void *) b );
1582 }
1583
1584
1585 #ifndef YY_ALWAYS_INTERACTIVE
1586 #ifndef YY_NEVER_INTERACTIVE
1587 extern int isatty YY_PROTO(( int ));
1588 #endif
1589 #endif
1590
1591 #ifdef YY_USE_PROTOS
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)1592 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1593 #else
1594 void yy_init_buffer( b, file )
1595 YY_BUFFER_STATE b;
1596 FILE *file;
1597 #endif
1598
1599
1600 {
1601 yy_flush_buffer( b );
1602
1603 b->yy_input_file = file;
1604 b->yy_fill_buffer = 1;
1605
1606 #if YY_ALWAYS_INTERACTIVE
1607 b->yy_is_interactive = 1;
1608 #else
1609 #if YY_NEVER_INTERACTIVE
1610 b->yy_is_interactive = 0;
1611 #else
1612 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1613 #endif
1614 #endif
1615 }
1616
1617
1618 #ifdef YY_USE_PROTOS
yy_flush_buffer(YY_BUFFER_STATE b)1619 void yy_flush_buffer( YY_BUFFER_STATE b )
1620 #else
1621 void yy_flush_buffer( b )
1622 YY_BUFFER_STATE b;
1623 #endif
1624
1625 {
1626 if ( ! b )
1627 return;
1628
1629 b->yy_n_chars = 0;
1630
1631 /* We always need two end-of-buffer characters. The first causes
1632 * a transition to the end-of-buffer state. The second causes
1633 * a jam in that state.
1634 */
1635 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1636 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1637
1638 b->yy_buf_pos = &b->yy_ch_buf[0];
1639
1640 b->yy_at_bol = 1;
1641 b->yy_buffer_status = YY_BUFFER_NEW;
1642
1643 if ( b == yy_current_buffer )
1644 yy_load_buffer_state();
1645 }
1646
1647
1648 #ifndef YY_NO_SCAN_BUFFER
1649 #ifdef YY_USE_PROTOS
yy_scan_buffer(char * base,yy_size_t size)1650 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1651 #else
1652 YY_BUFFER_STATE yy_scan_buffer( base, size )
1653 char *base;
1654 yy_size_t size;
1655 #endif
1656 {
1657 YY_BUFFER_STATE b;
1658
1659 if ( size < 2 ||
1660 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1661 base[size-1] != YY_END_OF_BUFFER_CHAR )
1662 /* They forgot to leave room for the EOB's. */
1663 return 0;
1664
1665 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1666 if ( ! b )
1667 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1668
1669 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1670 b->yy_buf_pos = b->yy_ch_buf = base;
1671 b->yy_is_our_buffer = 0;
1672 b->yy_input_file = 0;
1673 b->yy_n_chars = b->yy_buf_size;
1674 b->yy_is_interactive = 0;
1675 b->yy_at_bol = 1;
1676 b->yy_fill_buffer = 0;
1677 b->yy_buffer_status = YY_BUFFER_NEW;
1678
1679 yy_switch_to_buffer( b );
1680
1681 return b;
1682 }
1683 #endif
1684
1685
1686 #ifndef YY_NO_SCAN_STRING
1687 #ifdef YY_USE_PROTOS
yy_scan_string(yyconst char * yy_str)1688 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1689 #else
1690 YY_BUFFER_STATE yy_scan_string( yy_str )
1691 yyconst char *yy_str;
1692 #endif
1693 {
1694 int len;
1695 for ( len = 0; yy_str[len]; ++len )
1696 ;
1697
1698 return yy_scan_bytes( yy_str, len );
1699 }
1700 #endif
1701
1702
1703 #ifndef YY_NO_SCAN_BYTES
1704 #ifdef YY_USE_PROTOS
yy_scan_bytes(yyconst char * bytes,int len)1705 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1706 #else
1707 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1708 yyconst char *bytes;
1709 int len;
1710 #endif
1711 {
1712 YY_BUFFER_STATE b;
1713 char *buf;
1714 yy_size_t n;
1715 int i;
1716
1717 /* Get memory for full buffer, including space for trailing EOB's. */
1718 n = len + 2;
1719 buf = (char *) yy_flex_alloc( n );
1720 if ( ! buf )
1721 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1722
1723 for ( i = 0; i < len; ++i )
1724 buf[i] = bytes[i];
1725
1726 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1727
1728 b = yy_scan_buffer( buf, n );
1729 if ( ! b )
1730 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1731
1732 /* It's okay to grow etc. this buffer, and we should throw it
1733 * away when we're done.
1734 */
1735 b->yy_is_our_buffer = 1;
1736
1737 return b;
1738 }
1739 #endif
1740
1741
1742 #ifndef YY_NO_PUSH_STATE
1743 #ifdef YY_USE_PROTOS
yy_push_state(int new_state)1744 static void yy_push_state( int new_state )
1745 #else
1746 static void yy_push_state( new_state )
1747 int new_state;
1748 #endif
1749 {
1750 if ( yy_start_stack_ptr >= yy_start_stack_depth )
1751 {
1752 yy_size_t new_size;
1753
1754 yy_start_stack_depth += YY_START_STACK_INCR;
1755 new_size = yy_start_stack_depth * sizeof( int );
1756
1757 if ( ! yy_start_stack )
1758 yy_start_stack = (int *) yy_flex_alloc( new_size );
1759
1760 else
1761 yy_start_stack = (int *) yy_flex_realloc(
1762 (void *) yy_start_stack, new_size );
1763
1764 if ( ! yy_start_stack )
1765 YY_FATAL_ERROR(
1766 "out of memory expanding start-condition stack" );
1767 }
1768
1769 yy_start_stack[yy_start_stack_ptr++] = YY_START;
1770
1771 BEGIN(new_state);
1772 }
1773 #endif
1774
1775
1776 #ifndef YY_NO_POP_STATE
yy_pop_state()1777 static void yy_pop_state()
1778 {
1779 if ( --yy_start_stack_ptr < 0 )
1780 YY_FATAL_ERROR( "start-condition stack underflow" );
1781
1782 BEGIN(yy_start_stack[yy_start_stack_ptr]);
1783 }
1784 #endif
1785
1786
1787 #ifndef YY_NO_TOP_STATE
yy_top_state()1788 static int yy_top_state()
1789 {
1790 return yy_start_stack[yy_start_stack_ptr - 1];
1791 }
1792 #endif
1793
1794 #ifndef YY_EXIT_FAILURE
1795 #define YY_EXIT_FAILURE 2
1796 #endif
1797
1798 #ifdef YY_USE_PROTOS
yy_fatal_error(yyconst char msg[])1799 static void yy_fatal_error( yyconst char msg[] )
1800 #else
1801 static void yy_fatal_error( msg )
1802 char msg[];
1803 #endif
1804 {
1805 (void) fprintf( stderr, "%s\n", msg );
1806 exit( YY_EXIT_FAILURE );
1807 }
1808
1809
1810
1811 /* Redefine yyless() so it works in section 3 code. */
1812
1813 #undef yyless
1814 #define yyless(n) \
1815 do \
1816 { \
1817 /* Undo effects of setting up yytext. */ \
1818 yytext[yyleng] = yy_hold_char; \
1819 yy_c_buf_p = yytext + n; \
1820 yy_hold_char = *yy_c_buf_p; \
1821 *yy_c_buf_p = '\0'; \
1822 yyleng = n; \
1823 } \
1824 while ( 0 )
1825
1826
1827 /* Internal utility routines. */
1828
1829 #ifndef yytext_ptr
1830 #ifdef YY_USE_PROTOS
yy_flex_strncpy(char * s1,yyconst char * s2,int n)1831 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1832 #else
1833 static void yy_flex_strncpy( s1, s2, n )
1834 char *s1;
1835 yyconst char *s2;
1836 int n;
1837 #endif
1838 {
1839 register int i;
1840 for ( i = 0; i < n; ++i )
1841 s1[i] = s2[i];
1842 }
1843 #endif
1844
1845 #ifdef YY_NEED_STRLEN
1846 #ifdef YY_USE_PROTOS
yy_flex_strlen(yyconst char * s)1847 static int yy_flex_strlen( yyconst char *s )
1848 #else
1849 static int yy_flex_strlen( s )
1850 yyconst char *s;
1851 #endif
1852 {
1853 register int n;
1854 for ( n = 0; s[n]; ++n )
1855 ;
1856
1857 return n;
1858 }
1859 #endif
1860
1861
1862 #ifdef YY_USE_PROTOS
yy_flex_alloc(yy_size_t size)1863 static void *yy_flex_alloc( yy_size_t size )
1864 #else
1865 static void *yy_flex_alloc( size )
1866 yy_size_t size;
1867 #endif
1868 {
1869 return (void *) malloc( size );
1870 }
1871
1872 #ifdef YY_USE_PROTOS
yy_flex_realloc(void * ptr,yy_size_t size)1873 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1874 #else
1875 static void *yy_flex_realloc( ptr, size )
1876 void *ptr;
1877 yy_size_t size;
1878 #endif
1879 {
1880 /* The cast to (char *) in the following accommodates both
1881 * implementations that use char* generic pointers, and those
1882 * that use void* generic pointers. It works with the latter
1883 * because both ANSI C and C++ allow castless assignment from
1884 * any pointer type to void*, and deal with argument conversions
1885 * as though doing an assignment.
1886 */
1887 return (void *) realloc( (char *) ptr, size );
1888 }
1889
1890 #ifdef YY_USE_PROTOS
yy_flex_free(void * ptr)1891 static void yy_flex_free( void *ptr )
1892 #else
1893 static void yy_flex_free( ptr )
1894 void *ptr;
1895 #endif
1896 {
1897 free( ptr );
1898 }
1899
1900 #if YY_MAIN
main()1901 int main()
1902 {
1903 yylex();
1904 return 0;
1905 }
1906 #endif
1907 #line 130 "kr_pat_scan.l"
1908
1909
pplex(void)1910 int pplex(void)
1911 {
1912 int scanned;
1913
1914 if (scanner_pattern_end_flag)
1915 {
1916 scanner_pattern_end_flag = 0;
1917 yylval.value = 0.0;
1918 return PATTERNEND;
1919 }
1920 else if (scanner_no_class_flag)
1921 {
1922 scanner_no_class_flag = 0;
1923 yylval.value = 0.0;
1924 return PATTERNNOCLASS;
1925 }
1926 else
1927 {
1928 scanned = yylex();
1929 numbers_as_names = 0;
1930 return scanned;
1931 }
1932 }
1933
scanner_await_pattern_end(void)1934 void scanner_await_pattern_end(void)
1935 {
1936 scanner_pattern_end_flag = 1;
1937 }
1938
scanner_await_no_class(void)1939 void scanner_await_no_class(void)
1940 {
1941 scanner_no_class_flag = 1;
1942 }
1943
scanner_await_class(void)1944 void scanner_await_class(void)
1945 {
1946 numbers_as_names = 1;
1947 }
1948
scanner_init_scanner(FILE * in_file)1949 void scanner_init_scanner(FILE *in_file)
1950 {
1951 yyin = in_file;
1952 #ifdef FLEX_SCANNER
1953 yyrestart(yyin);
1954 #endif
1955 scanner_pattern_end_flag = 0;
1956 scanner_no_class_flag = 0;
1957 numbers_as_names = 0;
1958 }
1959