1
2 #line 3 "pl-lexer.c"
3
4 #define YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 39
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34
35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36 * if you want the limit (max/min) macros for int types.
37 */
38 #ifndef __STDC_LIMIT_MACROS
39 #define __STDC_LIMIT_MACROS 1
40 #endif
41
42 #include <inttypes.h>
43 typedef int8_t flex_int8_t;
44 typedef uint8_t flex_uint8_t;
45 typedef int16_t flex_int16_t;
46 typedef uint16_t flex_uint16_t;
47 typedef int32_t flex_int32_t;
48 typedef uint32_t flex_uint32_t;
49 #else
50 typedef signed char flex_int8_t;
51 typedef short int flex_int16_t;
52 typedef int flex_int32_t;
53 typedef unsigned char flex_uint8_t;
54 typedef unsigned short int flex_uint16_t;
55 typedef unsigned int flex_uint32_t;
56
57 /* Limits of integral types. */
58 #ifndef INT8_MIN
59 #define INT8_MIN (-128)
60 #endif
61 #ifndef INT16_MIN
62 #define INT16_MIN (-32767-1)
63 #endif
64 #ifndef INT32_MIN
65 #define INT32_MIN (-2147483647-1)
66 #endif
67 #ifndef INT8_MAX
68 #define INT8_MAX (127)
69 #endif
70 #ifndef INT16_MAX
71 #define INT16_MAX (32767)
72 #endif
73 #ifndef INT32_MAX
74 #define INT32_MAX (2147483647)
75 #endif
76 #ifndef UINT8_MAX
77 #define UINT8_MAX (255U)
78 #endif
79 #ifndef UINT16_MAX
80 #define UINT16_MAX (65535U)
81 #endif
82 #ifndef UINT32_MAX
83 #define UINT32_MAX (4294967295U)
84 #endif
85
86 #endif /* ! C99 */
87
88 #endif /* ! FLEXINT_H */
89
90 #ifdef __cplusplus
91
92 /* The "const" storage-class-modifier is valid. */
93 #define YY_USE_CONST
94
95 #else /* ! __cplusplus */
96
97 /* C99 requires __STDC__ to be defined as 1. */
98 #if defined (__STDC__)
99
100 #define YY_USE_CONST
101
102 #endif /* defined (__STDC__) */
103 #endif /* ! __cplusplus */
104
105 #ifdef YY_USE_CONST
106 #define yyconst const
107 #else
108 #define yyconst
109 #endif
110
111 /* Returned upon end-of-file. */
112 #define YY_NULL 0
113
114 /* Promotes a possibly negative, possibly signed char to an unsigned
115 * integer for use as an array index. If the signed char is negative,
116 * we want to instead treat it as an 8-bit unsigned char, hence the
117 * double cast.
118 */
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
120
121 /* Enter a start condition. This macro really ought to take a parameter,
122 * but we do it the disgusting crufty way forced on us by the ()-less
123 * definition of BEGIN.
124 */
125 #define BEGIN (yy_start) = 1 + 2 *
126
127 /* Translate the current start state into a value that can be later handed
128 * to BEGIN to return to the state. The YYSTATE alias is for lex
129 * compatibility.
130 */
131 #define YY_START (((yy_start) - 1) / 2)
132 #define YYSTATE YY_START
133
134 /* Action number for EOF rule of a given start state. */
135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
136
137 /* Special action meaning "start processing a new file". */
138 #define YY_NEW_FILE yyrestart(yyin )
139
140 #define YY_END_OF_BUFFER_CHAR 0
141
142 /* Size of default input buffer. */
143 #ifndef YY_BUF_SIZE
144 #define YY_BUF_SIZE 16384
145 #endif
146
147 /* The state buf must be large enough to hold one state per character in the main buffer.
148 */
149 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
150
151 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
152 #define YY_TYPEDEF_YY_BUFFER_STATE
153 typedef struct yy_buffer_state *YY_BUFFER_STATE;
154 #endif
155
156 #ifndef YY_TYPEDEF_YY_SIZE_T
157 #define YY_TYPEDEF_YY_SIZE_T
158 typedef size_t yy_size_t;
159 #endif
160
161 extern yy_size_t yyleng;
162
163 extern FILE *yyin, *yyout;
164
165 #define EOB_ACT_CONTINUE_SCAN 0
166 #define EOB_ACT_END_OF_FILE 1
167 #define EOB_ACT_LAST_MATCH 2
168
169 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
170 * access to the local variable yy_act. Since yyless() is a macro, it would break
171 * existing scanners that call yyless() from OUTSIDE yylex.
172 * One obvious solution it to make yy_act a global. I tried that, and saw
173 * a 5% performance hit in a non-yylineno scanner, because yy_act is
174 * normally declared as a register variable-- so it is not worth it.
175 */
176 #define YY_LESS_LINENO(n) \
177 do { \
178 int yyl;\
179 for ( yyl = n; yyl < yyleng; ++yyl )\
180 if ( yytext[yyl] == '\n' )\
181 --yylineno;\
182 }while(0)
183 #define YY_LINENO_REWIND_TO(dst) \
184 do {\
185 const char *p;\
186 for ( p = yy_cp-1; p >= (dst); --p)\
187 if ( *p == '\n' )\
188 --yylineno;\
189 }while(0)
190
191 /* Return all but the first "n" matched characters back to the input stream. */
192 #define yyless(n) \
193 do \
194 { \
195 /* Undo effects of setting up yytext. */ \
196 int yyless_macro_arg = (n); \
197 YY_LESS_LINENO(yyless_macro_arg);\
198 *yy_cp = (yy_hold_char); \
199 YY_RESTORE_YY_MORE_OFFSET \
200 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
201 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
202 } \
203 while ( 0 )
204
205 #define unput(c) yyunput( c, (yytext_ptr) )
206
207 #ifndef YY_STRUCT_YY_BUFFER_STATE
208 #define YY_STRUCT_YY_BUFFER_STATE
209 struct yy_buffer_state
210 {
211 FILE *yy_input_file;
212
213 char *yy_ch_buf; /* input buffer */
214 char *yy_buf_pos; /* current position in input buffer */
215
216 /* Size of input buffer in bytes, not including room for EOB
217 * characters.
218 */
219 yy_size_t yy_buf_size;
220
221 /* Number of characters read into yy_ch_buf, not including EOB
222 * characters.
223 */
224 yy_size_t yy_n_chars;
225
226 /* Whether we "own" the buffer - i.e., we know we created it,
227 * and can realloc() it to grow it, and should free() it to
228 * delete it.
229 */
230 int yy_is_our_buffer;
231
232 /* Whether this is an "interactive" input source; if so, and
233 * if we're using stdio for input, then we want to use getc()
234 * instead of fread(), to make sure we stop fetching input after
235 * each newline.
236 */
237 int yy_is_interactive;
238
239 /* Whether we're considered to be at the beginning of a line.
240 * If so, '^' rules will be active on the next match, otherwise
241 * not.
242 */
243 int yy_at_bol;
244
245 int yy_bs_lineno; /**< The line count. */
246 int yy_bs_column; /**< The column count. */
247
248 /* Whether to try to fill the input buffer when we reach the
249 * end of it.
250 */
251 int yy_fill_buffer;
252
253 int yy_buffer_status;
254
255 #define YY_BUFFER_NEW 0
256 #define YY_BUFFER_NORMAL 1
257 /* When an EOF's been seen but there's still some text to process
258 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
259 * shouldn't try reading from the input source any more. We might
260 * still have a bunch of tokens to match, though, because of
261 * possible backing-up.
262 *
263 * When we actually see the EOF, we change the status to "new"
264 * (via yyrestart()), so that the user can continue scanning by
265 * just pointing yyin at a new input file.
266 */
267 #define YY_BUFFER_EOF_PENDING 2
268
269 };
270 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
271
272 /* Stack of input buffers. */
273 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
274 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
275 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
276
277 /* We provide macros for accessing buffer states in case in the
278 * future we want to put the buffer states in a more general
279 * "scanner state".
280 *
281 * Returns the top of the stack, or NULL.
282 */
283 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
284 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
285 : NULL)
286
287 /* Same as previous macro, but useful when we know that the buffer stack is not
288 * NULL or when we need an lvalue. For internal use only.
289 */
290 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291
292 /* yy_hold_char holds the character lost when yytext is formed. */
293 static char yy_hold_char;
294 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
295 yy_size_t yyleng;
296
297 /* Points to current character in buffer. */
298 static char *yy_c_buf_p = (char *) 0;
299 static int yy_init = 0; /* whether we need to initialize */
300 static int yy_start = 0; /* start state number */
301
302 /* Flag which is used to allow yywrap()'s to do buffer switches
303 * instead of setting up a fresh yyin. A bit of a hack ...
304 */
305 static int yy_did_buffer_switch_on_eof;
306
307 void yyrestart (FILE *input_file );
308 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
309 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
310 void yy_delete_buffer (YY_BUFFER_STATE b );
311 void yy_flush_buffer (YY_BUFFER_STATE b );
312 void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
313 void yypop_buffer_state (void );
314
315 static void yyensure_buffer_stack (void );
316 static void yy_load_buffer_state (void );
317 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
318
319 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
320
321 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
322 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
323 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len );
324
325 void *yyalloc (yy_size_t );
326 void *yyrealloc (void *,yy_size_t );
327 void yyfree (void * );
328
329 #define yy_new_buffer yy_create_buffer
330
331 #define yy_set_interactive(is_interactive) \
332 { \
333 if ( ! YY_CURRENT_BUFFER ){ \
334 yyensure_buffer_stack (); \
335 YY_CURRENT_BUFFER_LVALUE = \
336 yy_create_buffer(yyin,YY_BUF_SIZE ); \
337 } \
338 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
339 }
340
341 #define yy_set_bol(at_bol) \
342 { \
343 if ( ! YY_CURRENT_BUFFER ){\
344 yyensure_buffer_stack (); \
345 YY_CURRENT_BUFFER_LVALUE = \
346 yy_create_buffer(yyin,YY_BUF_SIZE ); \
347 } \
348 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
349 }
350
351 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352
353 /* Begin user sect3 */
354
355 typedef unsigned char YY_CHAR;
356
357 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
358
359 typedef int yy_state_type;
360
361 #define YY_FLEX_LEX_COMPAT
362 extern int yylineno;
363
364 int yylineno = 1;
365
366 extern char yytext[];
367
368 static yy_state_type yy_get_previous_state (void );
369 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
370 static int yy_get_next_buffer (void );
371 static void yy_fatal_error (yyconst char msg[] );
372
373 /* Done after the current pattern has been matched and before the
374 * corresponding action - sets up yytext.
375 */
376 #define YY_DO_BEFORE_ACTION \
377 (yytext_ptr) = yy_bp; \
378 yyleng = (size_t) (yy_cp - yy_bp); \
379 (yy_hold_char) = *yy_cp; \
380 *yy_cp = '\0'; \
381 if ( yyleng >= YYLMAX ) \
382 YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
383 yy_flex_strncpy( yytext, (yytext_ptr), yyleng + 1 ); \
384 (yy_c_buf_p) = yy_cp;
385
386 #define YY_NUM_RULES 205
387 #define YY_END_OF_BUFFER 206
388 /* This struct is not used in this scanner,
389 but its presence is necessary. */
390 struct yy_trans_info
391 {
392 flex_int32_t yy_verify;
393 flex_int32_t yy_nxt;
394 };
395 static yyconst flex_int16_t yy_accept[800] =
396 { 0,
397 0, 0, 206, 204, 1, 2, 3, 4, 204, 204,
398 204, 204, 204, 204, 204, 204, 204, 204, 204, 204,
399 204, 204, 204, 204, 204, 204, 204, 204, 204, 204,
400 204, 1, 0, 0, 0, 0, 0, 0, 0, 0,
401 0, 0, 0, 0, 0, 0, 0, 0, 0, 180,
402 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
403 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
404 0, 0, 0, 0, 0, 0, 9, 0, 0, 0,
405 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
406 0, 0, 0, 0, 0, 0, 42, 0, 8, 8,
407
408 0, 0, 0, 0, 0, 0, 0, 0, 0, 6,
409 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
410 179, 0, 0, 0, 7, 0, 0, 31, 0, 44,
411 102, 41, 0, 0, 0, 0, 0, 0, 0, 5,
412 0, 0, 0, 107, 0, 0, 0, 9, 9, 43,
413 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
414 0, 0, 0, 0, 40, 0, 0, 0, 0, 0,
415 46, 0, 0, 0, 0, 0, 0, 0, 0, 171,
416 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
417 0, 0, 0, 0, 0, 0, 23, 0, 178, 0,
418
419 0, 151, 0, 0, 0, 45, 0, 0, 0, 0,
420 0, 0, 0, 0, 0, 77, 78, 79, 0, 0,
421 0, 0, 106, 75, 9, 150, 0, 0, 0, 0,
422 0, 0, 0, 0, 0, 0, 0, 0, 33, 0,
423 0, 0, 32, 0, 85, 86, 0, 82, 83, 84,
424 0, 0, 181, 0, 0, 0, 0, 47, 49, 0,
425 0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
426 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
427 0, 0, 0, 0, 0, 0, 0, 61, 67, 55,
428 60, 66, 54, 63, 69, 57, 62, 68, 56, 59,
429
430 65, 53, 58, 64, 52, 0, 177, 0, 0, 0,
431 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
432 0, 0, 0, 0, 0, 30, 48, 0, 0, 0,
433 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
434 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
435 188, 187, 189, 0, 0, 186, 0, 0, 0, 0,
436 0, 70, 71, 0, 0, 0, 0, 0, 0, 0,
437 0, 0, 50, 0, 0, 0, 0, 0, 0, 38,
438 0, 0, 37, 39, 0, 0, 0, 0, 0, 36,
439 0, 175, 0, 0, 0, 0, 0, 0, 89, 90,
440
441 80, 81, 0, 0, 11, 0, 100, 0, 0, 0,
442 0, 0, 0, 0, 0, 0, 0, 147, 0, 0,
443 0, 0, 0, 159, 24, 146, 0, 0, 0, 0,
444 0, 0, 110, 148, 0, 0, 0, 182, 0, 0,
445 0, 0, 0, 0, 0, 158, 157, 156, 0, 0,
446 0, 0, 0, 0, 0, 0, 73, 0, 0, 0,
447 0, 0, 0, 12, 0, 0, 51, 0, 0, 0,
448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
449 0, 0, 0, 16, 0, 0, 0, 0, 0, 0,
450 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
451
452 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
453 98, 0, 0, 0, 0, 0, 0, 0, 0, 0,
454 0, 149, 0, 0, 0, 0, 0, 0, 0, 0,
455 0, 0, 104, 105, 0, 15, 72, 88, 87, 0,
456 35, 74, 0, 183, 0, 0, 0, 0, 0, 0,
457 170, 0, 0, 0, 0, 169, 20, 184, 0, 173,
458 174, 0, 0, 0, 0, 14, 0, 0, 0, 0,
459 0, 145, 0, 0, 13, 0, 144, 0, 164, 163,
460 0, 0, 162, 0, 27, 0, 111, 109, 0, 0,
461 0, 0, 0, 112, 0, 0, 0, 0, 0, 0,
462
463 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
464 185, 0, 0, 115, 0, 28, 0, 0, 0, 0,
465 0, 0, 0, 0, 0, 0, 0, 26, 0, 0,
466 0, 0, 101, 0, 0, 0, 0, 153, 0, 0,
467 152, 114, 108, 154, 0, 0, 0, 29, 0, 0,
468 0, 0, 0, 0, 0, 0, 201, 0, 0, 0,
469 0, 0, 113, 91, 0, 0, 166, 165, 167, 0,
470 176, 0, 0, 21, 0, 76, 0, 120, 122, 119,
471 117, 123, 121, 116, 118, 141, 140, 142, 0, 161,
472 0, 0, 34, 0, 0, 0, 0, 155, 0, 0,
473
474 194, 0, 0, 0, 199, 202, 197, 103, 0, 17,
475 0, 0, 168, 0, 0, 22, 0, 143, 160, 0,
476 136, 138, 135, 133, 139, 137, 132, 134, 0, 192,
477 195, 190, 0, 0, 0, 0, 0, 25, 10, 0,
478 99, 0, 0, 0, 0, 203, 0, 0, 0, 93,
479 94, 95, 96, 97, 0, 0, 196, 0, 0, 200,
480 198, 0, 0, 0, 193, 191, 0, 0, 0, 0,
481 0, 0, 0, 0, 0, 0, 0, 128, 130, 127,
482 125, 131, 129, 124, 126, 0, 0, 0, 0, 0,
483 0, 0, 92, 0, 0, 0, 18, 19, 0
484
485 } ;
486
487 static yyconst flex_int32_t yy_ec[256] =
488 { 0,
489 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
490 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
491 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
492 1, 2, 1, 1, 1, 1, 1, 1, 1, 4,
493 5, 1, 6, 1, 6, 7, 8, 9, 10, 11,
494 12, 13, 14, 9, 9, 15, 15, 1, 1, 1,
495 1, 16, 1, 1, 17, 18, 19, 20, 21, 22,
496 23, 24, 25, 1, 26, 27, 28, 29, 30, 31,
497 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
499
500 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
501 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
502 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
503 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
504 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
505 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
506 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
507 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
508 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
509 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
510
511 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
512 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
513 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
514 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
515 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
516 1, 1, 1, 1, 1
517 } ;
518
519 static yyconst flex_int32_t yy_meta[42] =
520 { 0,
521 1, 2, 3, 1, 1, 4, 4, 1, 5, 5,
522 5, 5, 5, 5, 6, 1, 7, 7, 7, 7,
523 7, 7, 1, 1, 1, 1, 1, 1, 1, 1,
524 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
525 1
526 } ;
527
528 static yyconst flex_int16_t yy_base[806] =
529 { 0,
530 0, 0, 848, 849, 845, 849, 849, 849, 819, 15,
531 18, 53, 42, 806, 44, 817, 43, 806, 809, 32,
532 35, 65, 45, 72, 805, 64, 88, 810, 810, 33,
533 29, 836, 812, 815, 810, 811, 23, 831, 805, 54,
534 798, 71, 70, 809, 827, 77, 793, 89, 75, 800,
535 797, 808, 788, 821, 805, 804, 791, 801, 795, 786,
536 796, 778, 797, 778, 773, 781, 777, 781, 806, 779,
537 773, 776, 773, 778, 768, 784, 119, 769, 772, 101,
538 765, 772, 779, 101, 80, 109, 764, 769, 760, 767,
539 770, 769, 766, 771, 753, 756, 768, 755, 849, 781,
540
541 746, 748, 761, 750, 760, 760, 751, 747, 745, 771,
542 755, 746, 740, 744, 735, 104, 106, 108, 746, 741,
543 738, 729, 736, 741, 759, 740, 732, 849, 737, 43,
544 735, 739, 734, 727, 717, 717, 722, 722, 132, 136,
545 722, 731, 730, 849, 718, 721, 724, 0, 128, 849,
546 722, 133, 721, 133, 720, 715, 708, 709, 718, 717,
547 704, 713, 144, 162, 716, 697, 712, 695, 704, 711,
548 151, 707, 702, 694, 705, 703, 701, 166, 695, 849,
549 699, 699, 689, 696, 139, 680, 687, 686, 690, 695,
550 144, 159, 160, 177, 181, 182, 849, 684, 683, 199,
551
552 673, 201, 687, 671, 679, 689, 687, 673, 683, 211,
553 665, 667, 672, 663, 680, 849, 849, 849, 675, 667,
554 667, 177, 849, 849, 0, 187, 196, 662, 657, 672,
555 665, 659, 668, 668, 662, 649, 655, 654, 849, 647,
556 660, 655, 849, 644, 849, 849, 645, 849, 849, 849,
557 644, 657, 849, 651, 647, 650, 652, 655, 849, 649,
558 648, 634, 648, 649, 849, 646, 633, 626, 635, 626,
559 150, 623, 638, 139, 638, 623, 629, 634, 631, 624,
560 625, 624, 623, 86, 174, 620, 614, 849, 849, 849,
561 849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
562
563 849, 849, 849, 849, 849, 607, 849, 173, 622, 208,
564 608, 617, 606, 605, 624, 619, 603, 617, 613, 600,
565 38, 595, 614, 600, 611, 849, 849, 613, 601, 610,
566 598, 606, 601, 594, 603, 606, 605, 601, 593, 582,
567 597, 582, 220, 591, 585, 583, 578, 592, 577, 575,
568 849, 849, 849, 589, 577, 849, 572, 589, 578, 586,
569 577, 849, 849, 585, 582, 570, 569, 579, 580, 575,
570 571, 573, 577, 559, 566, 559, 568, 555, 552, 849,
571 569, 549, 849, 849, 567, 566, 553, 550, 553, 849,
572 543, 849, 545, 543, 541, 540, 538, 538, 849, 849,
573
574 849, 849, 207, 541, 849, 550, 849, 549, 212, 544,
575 551, 531, 549, 548, 536, 534, 535, 524, 543, 532,
576 525, 524, 525, 849, 849, 518, 527, 518, 531, 513,
577 528, 526, 849, 511, 520, 513, 520, 849, 523, 508,
578 502, 507, 505, 519, 507, 849, 849, 849, 516, 519,
579 222, 518, 512, 500, 511, 506, 849, 503, 505, 497,
580 496, 505, 492, 849, 489, 490, 849, 488, 498, 503,
581 490, 478, 496, 489, 494, 487, 486, 495, 490, 489,
582 481, 474, 488, 849, 466, 484, 471, 478, 473, 484,
583 483, 480, 477, 495, 455, 468, 473, 466, 465, 470,
584
585 473, 468, 471, 454, 465, 460, 463, 462, 465, 460,
586 849, 451, 450, 443, 453, 459, 453, 451, 440, 445,
587 450, 433, 448, 451, 224, 450, 432, 426, 434, 442,
588 423, 431, 849, 849, 425, 435, 849, 849, 849, 429,
589 849, 849, 423, 849, 432, 436, 419, 434, 419, 415,
590 849, 414, 413, 421, 430, 849, 849, 849, 422, 849,
591 849, 409, 403, 418, 423, 849, 415, 411, 247, 418,
592 402, 849, 401, 400, 849, 408, 849, 407, 849, 849,
593 404, 397, 849, 404, 849, 395, 849, 849, 394, 401,
594 397, 405, 423, 849, 391, 406, 388, 382, 390, 398,
595
596 379, 390, 391, 382, 381, 388, 383, 377, 389, 374,
597 849, 373, 382, 849, 382, 849, 384, 383, 382, 367,
598 366, 379, 372, 377, 362, 375, 361, 849, 143, 233,
599 234, 190, 849, 373, 372, 371, 356, 849, 364, 370,
600 849, 849, 849, 849, 359, 354, 252, 849, 359, 358,
601 359, 350, 349, 356, 363, 345, 849, 343, 343, 341,
602 358, 335, 849, 849, 344, 350, 849, 849, 849, 324,
603 849, 335, 337, 849, 323, 849, 317, 849, 849, 849,
604 849, 849, 849, 849, 849, 849, 849, 849, 312, 849,
605 322, 307, 849, 229, 237, 240, 230, 849, 324, 306,
606
607 849, 304, 304, 308, 318, 849, 317, 849, 312, 849,
608 309, 296, 849, 307, 292, 849, 298, 849, 849, 304,
609 849, 849, 849, 849, 849, 849, 849, 849, 103, 191,
610 849, 211, 218, 235, 239, 245, 278, 849, 849, 243,
611 849, 246, 238, 251, 252, 849, 244, 247, 261, 849,
612 849, 849, 849, 849, 259, 253, 849, 259, 260, 849,
613 849, 268, 277, 295, 849, 849, 281, 273, 298, 278,
614 273, 276, 286, 287, 279, 305, 287, 849, 849, 849,
615 849, 849, 849, 849, 849, 308, 277, 296, 281, 281,
616 290, 282, 849, 285, 299, 302, 849, 849, 849, 343,
617
618 349, 354, 360, 364, 366
619 } ;
620
621 static yyconst flex_int16_t yy_def[806] =
622 { 0,
623 799, 1, 799, 799, 799, 799, 799, 799, 799, 799,
624 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
625 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
626 799, 799, 799, 799, 799, 799, 799, 800, 799, 799,
627 799, 799, 799, 799, 801, 799, 799, 799, 799, 799,
628 799, 799, 799, 802, 799, 799, 799, 799, 799, 799,
629 799, 799, 799, 799, 799, 799, 799, 799, 803, 799,
630 799, 799, 799, 799, 799, 799, 804, 799, 799, 799,
631 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
632 799, 799, 799, 799, 799, 799, 799, 799, 799, 800,
633
634 799, 799, 799, 799, 799, 799, 799, 799, 799, 801,
635 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
636 799, 799, 799, 799, 802, 799, 799, 799, 799, 799,
637 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
638 799, 799, 799, 799, 799, 799, 799, 805, 804, 799,
639 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
640 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
641 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
642 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
643 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
644
645 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
646 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
647 799, 799, 799, 799, 805, 799, 799, 799, 799, 799,
648 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
649 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
650 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
651 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
652 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
653 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
654 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
655
656 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
657 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
658 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
659 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
660 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
661 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
662 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
663 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
664 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
665 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
666
667 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
668 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
669 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
670 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
671 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
672 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
673 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
674 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
675 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
676 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
677
678 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
679 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
680 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
681 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
682 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
683 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
684 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
685 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
686 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
687 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
688
689 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
690 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
691 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
692 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
693 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
694 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
695 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
696 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
697 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
698 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
699
700 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
701 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
702 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
703 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
704 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
705 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
706 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
707 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
708 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
709 799, 799, 799, 799, 799, 799, 799, 799, 0, 799,
710
711 799, 799, 799, 799, 799
712 } ;
713
714 static yyconst flex_int16_t yy_nxt[891] =
715 { 0,
716 4, 5, 6, 7, 8, 4, 4, 9, 4, 4,
717 4, 4, 4, 4, 4, 4, 10, 11, 12, 13,
718 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
719 24, 25, 26, 27, 28, 29, 30, 4, 31, 4,
720 4, 34, 36, 45, 54, 48, 69, 37, 58, 89,
721 206, 60, 91, 35, 38, 92, 59, 97, 98, 61,
722 49, 421, 46, 55, 62, 77, 70, 90, 50, 77,
723 102, 63, 422, 51, 103, 39, 40, 207, 41, 42,
724 52, 64, 43, 44, 78, 65, 66, 105, 71, 107,
725 48, 106, 72, 119, 67, 399, 400, 108, 111, 79,
726
727 68, 73, 120, 112, 74, 113, 116, 75, 80, 161,
728 114, 81, 162, 82, 83, 117, 118, 159, 84, 152,
729 77, 160, 85, 86, 77, 148, 163, 153, 191, 799,
730 193, 743, 195, 799, 148, 154, 192, 155, 194, 164,
731 196, 216, 217, 218, 140, 140, 140, 140, 140, 140,
732 227, 235, 228, 245, 246, 281, 229, 230, 258, 388,
733 231, 282, 288, 247, 289, 236, 259, 232, 384, 678,
734 233, 248, 249, 250, 389, 679, 290, 291, 294, 292,
735 295, 251, 266, 401, 402, 267, 385, 268, 269, 270,
736 271, 293, 296, 272, 343, 297, 273, 298, 274, 300,
737
738 303, 301, 304, 275, 344, 406, 346, 407, 744, 299,
739 347, 345, 349, 302, 305, 308, 684, 309, 310, 319,
740 311, 312, 685, 313, 348, 350, 314, 315, 745, 316,
741 331, 317, 409, 320, 321, 322, 442, 332, 323, 493,
742 488, 410, 489, 333, 494, 529, 334, 599, 569, 443,
743 680, 682, 746, 647, 723, 721, 727, 725, 530, 747,
744 600, 722, 728, 748, 629, 749, 755, 681, 683, 694,
745 756, 724, 757, 630, 726, 758, 759, 760, 695, 631,
746 761, 632, 762, 763, 696, 764, 697, 750, 751, 752,
747 753, 754, 765, 766, 767, 768, 769, 770, 771, 769,
748
749 776, 777, 778, 780, 782, 784, 786, 787, 779, 786,
750 790, 785, 791, 792, 793, 772, 794, 795, 796, 797,
751 781, 783, 798, 742, 773, 741, 740, 739, 738, 788,
752 774, 737, 775, 736, 735, 734, 733, 732, 731, 730,
753 729, 720, 789, 99, 99, 719, 99, 99, 99, 99,
754 110, 718, 717, 110, 110, 125, 716, 715, 125, 125,
755 125, 140, 714, 713, 140, 149, 712, 149, 149, 149,
756 225, 225, 711, 710, 709, 708, 707, 706, 705, 704,
757 703, 702, 701, 700, 699, 698, 693, 692, 691, 690,
758 689, 688, 687, 686, 677, 676, 675, 674, 673, 672,
759
760 671, 670, 669, 668, 667, 666, 665, 664, 663, 662,
761 661, 660, 659, 658, 657, 656, 655, 654, 653, 652,
762 651, 650, 649, 648, 647, 646, 645, 644, 643, 642,
763 641, 640, 639, 638, 637, 636, 635, 634, 633, 628,
764 627, 626, 625, 624, 623, 622, 621, 620, 619, 618,
765 617, 616, 615, 614, 613, 612, 611, 610, 609, 608,
766 607, 606, 605, 604, 603, 602, 601, 598, 597, 596,
767 595, 594, 593, 592, 591, 590, 589, 588, 587, 586,
768 585, 584, 583, 582, 581, 580, 579, 578, 577, 576,
769 575, 574, 573, 572, 571, 570, 569, 568, 567, 566,
770
771 565, 564, 563, 562, 561, 560, 559, 558, 557, 556,
772 555, 554, 553, 552, 551, 550, 549, 548, 547, 546,
773 545, 544, 543, 542, 541, 540, 539, 538, 537, 536,
774 535, 534, 533, 532, 531, 528, 527, 526, 525, 524,
775 523, 522, 521, 520, 519, 518, 517, 516, 515, 514,
776 513, 512, 511, 510, 509, 508, 507, 506, 505, 504,
777 503, 502, 501, 500, 499, 498, 497, 496, 495, 492,
778 491, 490, 487, 486, 485, 484, 483, 482, 481, 480,
779 479, 478, 477, 476, 475, 474, 473, 472, 471, 470,
780 469, 468, 467, 466, 465, 464, 463, 462, 461, 460,
781
782 459, 458, 457, 456, 455, 454, 453, 452, 451, 450,
783 449, 448, 447, 446, 445, 444, 441, 440, 439, 438,
784 437, 436, 435, 434, 433, 432, 431, 430, 429, 428,
785 427, 426, 425, 424, 423, 420, 419, 418, 417, 416,
786 415, 414, 413, 412, 411, 408, 405, 404, 403, 398,
787 397, 396, 395, 394, 393, 392, 391, 390, 387, 386,
788 383, 382, 381, 380, 379, 378, 377, 376, 375, 374,
789 373, 372, 371, 370, 369, 368, 367, 366, 365, 364,
790 363, 362, 361, 360, 359, 358, 357, 356, 355, 354,
791 353, 352, 351, 342, 341, 340, 339, 338, 337, 336,
792
793 335, 330, 329, 328, 327, 326, 325, 324, 318, 307,
794 306, 287, 286, 285, 284, 283, 280, 279, 278, 277,
795 276, 265, 264, 263, 262, 261, 260, 257, 256, 255,
796 254, 253, 252, 244, 243, 242, 241, 240, 239, 238,
797 237, 234, 226, 224, 223, 222, 221, 220, 219, 215,
798 214, 213, 212, 211, 210, 209, 208, 205, 204, 203,
799 799, 202, 201, 200, 199, 198, 197, 190, 189, 188,
800 187, 186, 799, 185, 184, 183, 182, 181, 180, 179,
801 178, 177, 100, 176, 175, 174, 173, 172, 171, 170,
802 169, 168, 167, 166, 165, 158, 157, 156, 151, 150,
803
804 147, 146, 145, 144, 143, 142, 141, 69, 139, 138,
805 137, 136, 135, 134, 133, 132, 131, 130, 129, 128,
806 127, 126, 54, 124, 123, 122, 121, 115, 45, 109,
807 104, 101, 100, 96, 95, 94, 93, 32, 88, 87,
808 76, 57, 56, 53, 47, 33, 32, 799, 3, 799,
809 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
810 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
811 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
812 799, 799, 799, 799, 799, 799, 799, 799, 799, 799
813 } ;
814
815 static yyconst flex_int16_t yy_chk[891] =
816 { 0,
817 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
818 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
819 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
820 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
821 1, 10, 11, 13, 17, 15, 23, 11, 20, 30,
822 130, 21, 31, 10, 12, 31, 20, 37, 37, 21,
823 15, 321, 13, 17, 21, 26, 23, 30, 15, 26,
824 40, 21, 321, 15, 40, 12, 12, 130, 12, 12,
825 15, 22, 12, 12, 26, 22, 22, 42, 24, 43,
826 48, 42, 24, 49, 22, 284, 284, 43, 46, 26,
827
828 22, 24, 49, 46, 24, 46, 48, 24, 27, 85,
829 46, 27, 85, 27, 27, 48, 48, 84, 27, 80,
830 77, 84, 27, 27, 77, 77, 86, 80, 116, 149,
831 117, 729, 118, 149, 149, 80, 116, 80, 117, 86,
832 118, 139, 139, 139, 140, 140, 140, 140, 140, 140,
833 152, 154, 152, 163, 163, 185, 152, 152, 171, 274,
834 152, 185, 191, 163, 191, 154, 171, 152, 271, 629,
835 152, 164, 164, 164, 274, 629, 191, 192, 193, 192,
836 193, 164, 178, 285, 285, 178, 271, 178, 178, 178,
837 178, 192, 193, 178, 222, 194, 178, 194, 178, 195,
838
839 196, 195, 196, 178, 222, 308, 226, 308, 730, 194,
840 226, 222, 227, 195, 196, 200, 632, 200, 200, 202,
841 200, 200, 632, 200, 226, 227, 200, 200, 732, 200,
842 210, 200, 310, 202, 202, 202, 343, 210, 202, 409,
843 403, 310, 403, 210, 409, 451, 210, 525, 569, 343,
844 630, 631, 733, 647, 695, 694, 697, 696, 451, 734,
845 525, 694, 697, 735, 569, 736, 740, 630, 631, 647,
846 742, 695, 743, 569, 696, 744, 745, 747, 647, 569,
847 748, 569, 749, 755, 647, 756, 647, 737, 737, 737,
848 737, 737, 758, 759, 762, 763, 764, 767, 768, 769,
849
850 770, 771, 772, 773, 774, 775, 776, 777, 772, 786,
851 787, 775, 788, 789, 790, 769, 791, 792, 794, 795,
852 773, 774, 796, 720, 769, 717, 715, 714, 712, 786,
853 769, 711, 769, 709, 707, 705, 704, 703, 702, 700,
854 699, 692, 786, 800, 800, 691, 800, 800, 800, 800,
855 801, 689, 677, 801, 801, 802, 675, 673, 802, 802,
856 802, 803, 672, 670, 803, 804, 666, 804, 804, 804,
857 805, 805, 665, 662, 661, 660, 659, 658, 656, 655,
858 654, 653, 652, 651, 650, 649, 646, 645, 640, 639,
859 637, 636, 635, 634, 627, 626, 625, 624, 623, 622,
860
861 621, 620, 619, 618, 617, 615, 613, 612, 610, 609,
862 608, 607, 606, 605, 604, 603, 602, 601, 600, 599,
863 598, 597, 596, 595, 593, 592, 591, 590, 589, 586,
864 584, 582, 581, 578, 576, 574, 573, 571, 570, 568,
865 567, 565, 564, 563, 562, 559, 555, 554, 553, 552,
866 550, 549, 548, 547, 546, 545, 543, 540, 536, 535,
867 532, 531, 530, 529, 528, 527, 526, 524, 523, 522,
868 521, 520, 519, 518, 517, 516, 515, 514, 513, 512,
869 510, 509, 508, 507, 506, 505, 504, 503, 502, 501,
870 500, 499, 498, 497, 496, 495, 494, 493, 492, 491,
871
872 490, 489, 488, 487, 486, 485, 483, 482, 481, 480,
873 479, 478, 477, 476, 475, 474, 473, 472, 471, 470,
874 469, 468, 466, 465, 463, 462, 461, 460, 459, 458,
875 456, 455, 454, 453, 452, 450, 449, 445, 444, 443,
876 442, 441, 440, 439, 437, 436, 435, 434, 432, 431,
877 430, 429, 428, 427, 426, 423, 422, 421, 420, 419,
878 418, 417, 416, 415, 414, 413, 412, 411, 410, 408,
879 406, 404, 398, 397, 396, 395, 394, 393, 391, 389,
880 388, 387, 386, 385, 382, 381, 379, 378, 377, 376,
881 375, 374, 373, 372, 371, 370, 369, 368, 367, 366,
882
883 365, 364, 361, 360, 359, 358, 357, 355, 354, 350,
884 349, 348, 347, 346, 345, 344, 342, 341, 340, 339,
885 338, 337, 336, 335, 334, 333, 332, 331, 330, 329,
886 328, 325, 324, 323, 322, 320, 319, 318, 317, 316,
887 315, 314, 313, 312, 311, 309, 306, 287, 286, 283,
888 282, 281, 280, 279, 278, 277, 276, 275, 273, 272,
889 270, 269, 268, 267, 266, 264, 263, 262, 261, 260,
890 258, 257, 256, 255, 254, 252, 251, 247, 244, 242,
891 241, 240, 238, 237, 236, 235, 234, 233, 232, 231,
892 230, 229, 228, 221, 220, 219, 215, 214, 213, 212,
893
894 211, 209, 208, 207, 206, 205, 204, 203, 201, 199,
895 198, 190, 189, 188, 187, 186, 184, 183, 182, 181,
896 179, 177, 176, 175, 174, 173, 172, 170, 169, 168,
897 167, 166, 165, 162, 161, 160, 159, 158, 157, 156,
898 155, 153, 151, 147, 146, 145, 143, 142, 141, 138,
899 137, 136, 135, 134, 133, 132, 131, 129, 127, 126,
900 125, 124, 123, 122, 121, 120, 119, 115, 114, 113,
901 112, 111, 110, 109, 108, 107, 106, 105, 104, 103,
902 102, 101, 100, 98, 97, 96, 95, 94, 93, 92,
903 91, 90, 89, 88, 87, 83, 82, 81, 79, 78,
904
905 76, 75, 74, 73, 72, 71, 70, 69, 68, 67,
906 66, 65, 64, 63, 62, 61, 60, 59, 58, 57,
907 56, 55, 54, 53, 52, 51, 50, 47, 45, 44,
908 41, 39, 38, 36, 35, 34, 33, 32, 29, 28,
909 25, 19, 18, 16, 14, 9, 5, 3, 799, 799,
910 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
911 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
912 799, 799, 799, 799, 799, 799, 799, 799, 799, 799,
913 799, 799, 799, 799, 799, 799, 799, 799, 799, 799
914 } ;
915
916 /* Table of booleans, true if rule could match eol. */
917 static yyconst flex_int32_t yy_rule_can_match_eol[206] =
918 { 0,
919 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
920 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
921 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
922 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
923 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
924 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
925 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
926 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
927 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
928 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
929 0, 0, 0, 0, 0, 0, };
930
931 static yy_state_type yy_last_accepting_state;
932 static char *yy_last_accepting_cpos;
933
934 extern int yy_flex_debug;
935 int yy_flex_debug = 0;
936
937 /* The intent behind this definition is that it'll catch
938 * any uses of REJECT which flex missed.
939 */
940 #define REJECT reject_used_but_not_detected
941 #define yymore() yymore_used_but_not_detected
942 #define YY_MORE_ADJ 0
943 #define YY_RESTORE_YY_MORE_OFFSET
944 #ifndef YYLMAX
945 #define YYLMAX 8192
946 #endif
947
948 char yytext[YYLMAX];
949 char *yytext_ptr;
950 #line 1 "pl-lexer.l"
951 #line 4 "pl-lexer.l"
952 /* pl-lexer.l: Lexical analysis of property list files.
953
954 This file is part of Omega,
955 which is based on the web2c distribution of TeX,
956
957 Copyright (c) 1994--2001 John Plaice and Yannis Haralambous
958 Copyright (c) 2002 Roozbeh Pournader
959
960 Omega is free software; you can redistribute it and/or modify
961 it under the terms of the GNU General Public License as published by
962 the Free Software Foundation; either version 2 of the License, or
963 (at your option) any later version.
964
965 Omega is distributed in the hope that it will be useful,
966 but WITHOUT ANY WARRANTY; without even the implied warranty of
967 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
968 GNU General Public License for more details.
969
970 You should have received a copy of the GNU General Public License
971 along with Omega; if not, write to the Free Software Foundation, Inc.,
972 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
973 */
974
975 #include <kpathsea/lib.h>
976 #include <kpathsea/c-memstr.h>
977 #include "parser.h"
978 #include "pl-parser.h"
979 #include "manifests.h"
980 #include "error_routines.h"
981 #ifdef __cplusplus
982 #define yyinput input
983 #endif
984
985 int line_number = 1;
986 extern YYSTYPE yylval;
987
988 /* POTENTIAL BUG: saved_text could be run over; should check */
989 #define MAX_PTR 10000
990 char saved_text[MAX_PTR];
991
992 static void scan_int(unsigned);
993 static void scan_char(void);
994 static void scan_fix(void);
995 static void scan_string(const char *, unsigned, unsigned);
996 static void scan_hex_string(void);
997
998 #define KEEP_MIN 0
999 #define KEEP_NONE 0
1000 #define KEEP_ALL 1
1001 #define KEEP_CONVERT 2
1002 #define KEEP_MAX 2
1003
1004 #define BASE_MIN 2
1005 #define BASE_MAX 16
1006
1007 /* For Solaris's lex, to increase tables sizes --RP */
1008 /* Space before number keeps ancient flex happy. */
1009 #line 1010 "pl-lexer.c"
1010
1011 #define INITIAL 0
1012
1013 #ifndef YY_NO_UNISTD_H
1014 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1015 * down here because we want the user's section 1 to have been scanned first.
1016 * The user has a chance to override it with an option.
1017 */
1018 #include <unistd.h>
1019 #endif
1020
1021 #ifndef YY_EXTRA_TYPE
1022 #define YY_EXTRA_TYPE void *
1023 #endif
1024
1025 static int yy_init_globals (void );
1026
1027 /* Accessor methods to globals.
1028 These are made visible to non-reentrant scanners for convenience. */
1029
1030 int yylex_destroy (void );
1031
1032 int yyget_debug (void );
1033
1034 void yyset_debug (int debug_flag );
1035
1036 YY_EXTRA_TYPE yyget_extra (void );
1037
1038 void yyset_extra (YY_EXTRA_TYPE user_defined );
1039
1040 FILE *yyget_in (void );
1041
1042 void yyset_in (FILE * in_str );
1043
1044 FILE *yyget_out (void );
1045
1046 void yyset_out (FILE * out_str );
1047
1048 yy_size_t yyget_leng (void );
1049
1050 char *yyget_text (void );
1051
1052 int yyget_lineno (void );
1053
1054 void yyset_lineno (int line_number );
1055
1056 /* Macros after this point can all be overridden by user definitions in
1057 * section 1.
1058 */
1059
1060 #ifndef YY_SKIP_YYWRAP
1061 #ifdef __cplusplus
1062 extern "C" int yywrap (void );
1063 #else
1064 extern int yywrap (void );
1065 #endif
1066 #endif
1067
1068 static void yyunput (int c,char *buf_ptr );
1069
1070 #ifndef yytext_ptr
1071 static void yy_flex_strncpy (char *,yyconst char *,int );
1072 #endif
1073
1074 #ifdef YY_NEED_STRLEN
1075 static int yy_flex_strlen (yyconst char * );
1076 #endif
1077
1078 #ifndef YY_NO_INPUT
1079
1080 #ifdef __cplusplus
1081 static int yyinput (void );
1082 #else
1083 static int input (void );
1084 #endif
1085
1086 #endif
1087
1088 /* Amount of stuff to slurp up with each read. */
1089 #ifndef YY_READ_BUF_SIZE
1090 #define YY_READ_BUF_SIZE 8192
1091 #endif
1092
1093 /* Copy whatever the last rule matched to the standard output. */
1094 #ifndef ECHO
1095 /* This used to be an fputs(), but since the string might contain NUL's,
1096 * we now use fwrite().
1097 */
1098 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1099 #endif
1100
1101 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1102 * is returned in "result".
1103 */
1104 #ifndef YY_INPUT
1105 #define YY_INPUT(buf,result,max_size) \
1106 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1107 { \
1108 int c = '*'; \
1109 size_t n; \
1110 for ( n = 0; n < max_size && \
1111 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1112 buf[n] = (char) c; \
1113 if ( c == '\n' ) \
1114 buf[n++] = (char) c; \
1115 if ( c == EOF && ferror( yyin ) ) \
1116 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1117 result = n; \
1118 } \
1119 else \
1120 { \
1121 errno=0; \
1122 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1123 { \
1124 if( errno != EINTR) \
1125 { \
1126 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1127 break; \
1128 } \
1129 errno=0; \
1130 clearerr(yyin); \
1131 } \
1132 }\
1133 \
1134
1135 #endif
1136
1137 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1138 * we don't want an extra ';' after the "return" because that will cause
1139 * some compilers to complain about unreachable statements.
1140 */
1141 #ifndef yyterminate
1142 #define yyterminate() return YY_NULL
1143 #endif
1144
1145 /* Number of entries by which start-condition stack grows. */
1146 #ifndef YY_START_STACK_INCR
1147 #define YY_START_STACK_INCR 25
1148 #endif
1149
1150 /* Report a fatal error. */
1151 #ifndef YY_FATAL_ERROR
1152 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1153 #endif
1154
1155 /* end tables serialization structures and prototypes */
1156
1157 /* Default declaration of generated scanner - a define so the user can
1158 * easily add parameters.
1159 */
1160 #ifndef YY_DECL
1161 #define YY_DECL_IS_OURS 1
1162
1163 extern int yylex (void);
1164
1165 #define YY_DECL int yylex (void)
1166 #endif /* !YY_DECL */
1167
1168 /* Code executed at the beginning of each rule, after yytext and yyleng
1169 * have been set up.
1170 */
1171 #ifndef YY_USER_ACTION
1172 #define YY_USER_ACTION
1173 #endif
1174
1175 /* Code executed at the end of each rule. */
1176 #ifndef YY_BREAK
1177 #define YY_BREAK break;
1178 #endif
1179
1180 #define YY_RULE_SETUP \
1181 YY_USER_ACTION
1182
1183 /** The main scanner function which does all the work.
1184 */
1185 YY_DECL
1186 {
1187 register yy_state_type yy_current_state;
1188 register char *yy_cp, *yy_bp;
1189 register int yy_act;
1190
1191 if ( !(yy_init) )
1192 {
1193 (yy_init) = 1;
1194
1195 #ifdef YY_USER_INIT
1196 YY_USER_INIT;
1197 #endif
1198
1199 if ( ! (yy_start) )
1200 (yy_start) = 1; /* first start state */
1201
1202 if ( ! yyin )
1203 yyin = stdin;
1204
1205 if ( ! yyout )
1206 yyout = stdout;
1207
1208 if ( ! YY_CURRENT_BUFFER ) {
1209 yyensure_buffer_stack ();
1210 YY_CURRENT_BUFFER_LVALUE =
1211 yy_create_buffer(yyin,YY_BUF_SIZE );
1212 }
1213
1214 yy_load_buffer_state( );
1215 }
1216
1217 {
1218 #line 74 "pl-lexer.l"
1219
1220
1221 #line 1222 "pl-lexer.c"
1222
1223 while ( 1 ) /* loops until end-of-file is reached */
1224 {
1225 yy_cp = (yy_c_buf_p);
1226
1227 /* Support of yytext. */
1228 *yy_cp = (yy_hold_char);
1229
1230 /* yy_bp points to the position in yy_ch_buf of the start of
1231 * the current run.
1232 */
1233 yy_bp = yy_cp;
1234
1235 yy_current_state = (yy_start);
1236 yy_match:
1237 do
1238 {
1239 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1240 if ( yy_accept[yy_current_state] )
1241 {
1242 (yy_last_accepting_state) = yy_current_state;
1243 (yy_last_accepting_cpos) = yy_cp;
1244 }
1245 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1246 {
1247 yy_current_state = (int) yy_def[yy_current_state];
1248 if ( yy_current_state >= 800 )
1249 yy_c = yy_meta[(unsigned int) yy_c];
1250 }
1251 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1252 ++yy_cp;
1253 }
1254 while ( yy_current_state != 799 );
1255 yy_cp = (yy_last_accepting_cpos);
1256 yy_current_state = (yy_last_accepting_state);
1257
1258 yy_find_action:
1259 yy_act = yy_accept[yy_current_state];
1260
1261 YY_DO_BEFORE_ACTION;
1262
1263 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1264 {
1265 yy_size_t yyl;
1266 for ( yyl = 0; yyl < yyleng; ++yyl )
1267 if ( yytext[yyl] == '\n' )
1268
1269 yylineno++;
1270 ;
1271 }
1272
1273 do_action: /* This label is used only to access EOF actions. */
1274
1275 switch ( yy_act )
1276 { /* beginning of action switch */
1277 case 0: /* must back up */
1278 /* undo the effects of YY_DO_BEFORE_ACTION */
1279 *yy_cp = (yy_hold_char);
1280 yy_cp = (yy_last_accepting_cpos);
1281 yy_current_state = (yy_last_accepting_state);
1282 goto yy_find_action;
1283
1284 case 1:
1285 YY_RULE_SETUP
1286 #line 76 "pl-lexer.l"
1287 {}
1288 YY_BREAK
1289 case 2:
1290 /* rule 2 can match eol */
1291 YY_RULE_SETUP
1292 #line 77 "pl-lexer.l"
1293 {line_number++; }
1294 YY_BREAK
1295 case 3:
1296 YY_RULE_SETUP
1297 #line 79 "pl-lexer.l"
1298 return(LEFT);
1299 YY_BREAK
1300 case 4:
1301 YY_RULE_SETUP
1302 #line 80 "pl-lexer.l"
1303 return(RIGHT);
1304 YY_BREAK
1305 case 5:
1306 YY_RULE_SETUP
1307 #line 82 "pl-lexer.l"
1308 {scan_int(8); return(NUMBER); }
1309 YY_BREAK
1310 case 6:
1311 YY_RULE_SETUP
1312 #line 83 "pl-lexer.l"
1313 {scan_int(10); return(NUMBER); }
1314 YY_BREAK
1315 case 7:
1316 YY_RULE_SETUP
1317 #line 84 "pl-lexer.l"
1318 {scan_int(16); return(NUMBER); }
1319 YY_BREAK
1320 case 8:
1321 YY_RULE_SETUP
1322 #line 85 "pl-lexer.l"
1323 {scan_char(); return(NUMBER); }
1324 YY_BREAK
1325 case 9:
1326 YY_RULE_SETUP
1327 #line 86 "pl-lexer.l"
1328 {scan_fix(); return(FIX); }
1329 YY_BREAK
1330 case 10:
1331 YY_RULE_SETUP
1332 #line 88 "pl-lexer.l"
1333 {scan_string("CODINGSCHEME", KEEP_CONVERT, LEN_CODING_SCHEME);
1334 return(CODINGSCHEME); }
1335 YY_BREAK
1336 case 11:
1337 YY_RULE_SETUP
1338 #line 90 "pl-lexer.l"
1339 {scan_string("FAMILY", KEEP_CONVERT, LEN_FAMILY);
1340 return(FAMILY); }
1341 YY_BREAK
1342 case 12:
1343 YY_RULE_SETUP
1344 #line 92 "pl-lexer.l"
1345 {scan_string("VTITLE", KEEP_ALL, LEN_VTITLE);
1346 return(VTITLE); }
1347 YY_BREAK
1348 case 13:
1349 YY_RULE_SETUP
1350 #line 94 "pl-lexer.l"
1351 {scan_string("FONTNAME", KEEP_ALL, LEN_FONT_NAME);
1352 return(FONTNAME); }
1353 YY_BREAK
1354 case 14:
1355 YY_RULE_SETUP
1356 #line 96 "pl-lexer.l"
1357 {scan_string("FONTAREA", KEEP_ALL, LEN_FONT_AREA);
1358 return(FONTAREA); }
1359 YY_BREAK
1360 case 15:
1361 YY_RULE_SETUP
1362 #line 98 "pl-lexer.l"
1363 {scan_string("SPECIAL", KEEP_ALL, 0);
1364 return(SPECIAL); }
1365 YY_BREAK
1366 case 16:
1367 YY_RULE_SETUP
1368 #line 100 "pl-lexer.l"
1369 {scan_string("COMMENT", KEEP_NONE, 0);
1370 return(COMMENT); }
1371 YY_BREAK
1372 case 17:
1373 YY_RULE_SETUP
1374 #line 103 "pl-lexer.l"
1375 {scan_hex_string(); return(SPECIALHEX); }
1376 YY_BREAK
1377 case 18:
1378 YY_RULE_SETUP
1379 #line 106 "pl-lexer.l"
1380 {yylval.yint=1; return(SEVENBITSAFEFLAG); }
1381 YY_BREAK
1382 case 19:
1383 YY_RULE_SETUP
1384 #line 107 "pl-lexer.l"
1385 {yylval.yint=0; return(SEVENBITSAFEFLAG); }
1386 YY_BREAK
1387 case 20:
1388 YY_RULE_SETUP
1389 #line 109 "pl-lexer.l"
1390 return(CHECKSUM);
1391 YY_BREAK
1392 case 21:
1393 YY_RULE_SETUP
1394 #line 110 "pl-lexer.l"
1395 return(DESIGNSIZE);
1396 YY_BREAK
1397 case 22:
1398 YY_RULE_SETUP
1399 #line 111 "pl-lexer.l"
1400 return(DESIGNUNITS);
1401 YY_BREAK
1402 case 23:
1403 YY_RULE_SETUP
1404 #line 112 "pl-lexer.l"
1405 return(FACE);
1406 YY_BREAK
1407 case 24:
1408 YY_RULE_SETUP
1409 #line 113 "pl-lexer.l"
1410 return(HEADER);
1411 YY_BREAK
1412 case 25:
1413 YY_RULE_SETUP
1414 #line 114 "pl-lexer.l"
1415 return(BOUNDARYCHAR);
1416 YY_BREAK
1417 case 26:
1418 YY_RULE_SETUP
1419 #line 115 "pl-lexer.l"
1420 return(FONTDIMEN);
1421 YY_BREAK
1422 case 27:
1423 YY_RULE_SETUP
1424 #line 116 "pl-lexer.l"
1425 return(LIGTABLE);
1426 YY_BREAK
1427 case 28:
1428 YY_RULE_SETUP
1429 #line 117 "pl-lexer.l"
1430 return(CHARACTER);
1431 YY_BREAK
1432 case 29:
1433 YY_RULE_SETUP
1434 #line 119 "pl-lexer.l"
1435 return(PARAMETER);
1436 YY_BREAK
1437 case 30:
1438 YY_RULE_SETUP
1439 #line 120 "pl-lexer.l"
1440 return(LABEL);
1441 YY_BREAK
1442 case 31:
1443 YY_RULE_SETUP
1444 #line 121 "pl-lexer.l"
1445 return(KRN);
1446 YY_BREAK
1447 case 32:
1448 YY_RULE_SETUP
1449 #line 122 "pl-lexer.l"
1450 return(STOP);
1451 YY_BREAK
1452 case 33:
1453 YY_RULE_SETUP
1454 #line 123 "pl-lexer.l"
1455 return(SKIP);
1456 YY_BREAK
1457 case 34:
1458 YY_RULE_SETUP
1459 #line 124 "pl-lexer.l"
1460 return(NEXTLARGER);
1461 YY_BREAK
1462 case 35:
1463 YY_RULE_SETUP
1464 #line 125 "pl-lexer.l"
1465 return(VARCHAR);
1466 YY_BREAK
1467 case 36:
1468 YY_RULE_SETUP
1469 #line 127 "pl-lexer.l"
1470 {yylval.yint = C_WD; return(CHARMEASURE); }
1471 YY_BREAK
1472 case 37:
1473 YY_RULE_SETUP
1474 #line 128 "pl-lexer.l"
1475 {yylval.yint = C_HT; return(CHARMEASURE); }
1476 YY_BREAK
1477 case 38:
1478 YY_RULE_SETUP
1479 #line 129 "pl-lexer.l"
1480 {yylval.yint = C_DP; return(CHARMEASURE); }
1481 YY_BREAK
1482 case 39:
1483 YY_RULE_SETUP
1484 #line 130 "pl-lexer.l"
1485 {yylval.yint = C_IC; return(CHARMEASURE); }
1486 YY_BREAK
1487 case 40:
1488 YY_RULE_SETUP
1489 #line 132 "pl-lexer.l"
1490 {yylval.yint = E_TOP; return(EXTEN); }
1491 YY_BREAK
1492 case 41:
1493 YY_RULE_SETUP
1494 #line 133 "pl-lexer.l"
1495 {yylval.yint = E_MID; return(EXTEN); }
1496 YY_BREAK
1497 case 42:
1498 YY_RULE_SETUP
1499 #line 134 "pl-lexer.l"
1500 {yylval.yint = E_BOT; return(EXTEN); }
1501 YY_BREAK
1502 case 43:
1503 YY_RULE_SETUP
1504 #line 135 "pl-lexer.l"
1505 {yylval.yint = E_REP; return(EXTEN); }
1506 YY_BREAK
1507 case 44:
1508 YY_RULE_SETUP
1509 #line 137 "pl-lexer.l"
1510 {yylval.yint = L_0; return(LIG); }
1511 YY_BREAK
1512 case 45:
1513 YY_RULE_SETUP
1514 #line 138 "pl-lexer.l"
1515 {yylval.yint = L_B; return(LIG); }
1516 YY_BREAK
1517 case 46:
1518 YY_RULE_SETUP
1519 #line 139 "pl-lexer.l"
1520 {yylval.yint = L_A; return(LIG); }
1521 YY_BREAK
1522 case 47:
1523 YY_RULE_SETUP
1524 #line 140 "pl-lexer.l"
1525 {yylval.yint = L_AB; return(LIG); }
1526 YY_BREAK
1527 case 48:
1528 YY_RULE_SETUP
1529 #line 141 "pl-lexer.l"
1530 {yylval.yint = L_Bx; return(LIG); }
1531 YY_BREAK
1532 case 49:
1533 YY_RULE_SETUP
1534 #line 142 "pl-lexer.l"
1535 {yylval.yint = L_Ax; return(LIG); }
1536 YY_BREAK
1537 case 50:
1538 YY_RULE_SETUP
1539 #line 143 "pl-lexer.l"
1540 {yylval.yint = L_ABx; return(LIG); }
1541 YY_BREAK
1542 case 51:
1543 YY_RULE_SETUP
1544 #line 144 "pl-lexer.l"
1545 {yylval.yint = L_ABxx; return(LIG); }
1546 YY_BREAK
1547 case 52:
1548 YY_RULE_SETUP
1549 #line 146 "pl-lexer.l"
1550 {yylval.yint = F_MRR; return(NUMBER); }
1551 YY_BREAK
1552 case 53:
1553 YY_RULE_SETUP
1554 #line 147 "pl-lexer.l"
1555 {yylval.yint = F_MIR; return(NUMBER); }
1556 YY_BREAK
1557 case 54:
1558 YY_RULE_SETUP
1559 #line 148 "pl-lexer.l"
1560 {yylval.yint = F_BRR; return(NUMBER); }
1561 YY_BREAK
1562 case 55:
1563 YY_RULE_SETUP
1564 #line 149 "pl-lexer.l"
1565 {yylval.yint = F_BIR; return(NUMBER); }
1566 YY_BREAK
1567 case 56:
1568 YY_RULE_SETUP
1569 #line 150 "pl-lexer.l"
1570 {yylval.yint = F_LRR; return(NUMBER); }
1571 YY_BREAK
1572 case 57:
1573 YY_RULE_SETUP
1574 #line 151 "pl-lexer.l"
1575 {yylval.yint = F_LIR; return(NUMBER); }
1576 YY_BREAK
1577 case 58:
1578 YY_RULE_SETUP
1579 #line 152 "pl-lexer.l"
1580 {yylval.yint = F_MRC; return(NUMBER); }
1581 YY_BREAK
1582 case 59:
1583 YY_RULE_SETUP
1584 #line 153 "pl-lexer.l"
1585 {yylval.yint = F_MIC; return(NUMBER); }
1586 YY_BREAK
1587 case 60:
1588 YY_RULE_SETUP
1589 #line 154 "pl-lexer.l"
1590 {yylval.yint = F_BRC; return(NUMBER); }
1591 YY_BREAK
1592 case 61:
1593 YY_RULE_SETUP
1594 #line 155 "pl-lexer.l"
1595 {yylval.yint = F_BIC; return(NUMBER); }
1596 YY_BREAK
1597 case 62:
1598 YY_RULE_SETUP
1599 #line 156 "pl-lexer.l"
1600 {yylval.yint = F_LRC; return(NUMBER); }
1601 YY_BREAK
1602 case 63:
1603 YY_RULE_SETUP
1604 #line 157 "pl-lexer.l"
1605 {yylval.yint = F_LIC; return(NUMBER); }
1606 YY_BREAK
1607 case 64:
1608 YY_RULE_SETUP
1609 #line 158 "pl-lexer.l"
1610 {yylval.yint = F_MRE; return(NUMBER); }
1611 YY_BREAK
1612 case 65:
1613 YY_RULE_SETUP
1614 #line 159 "pl-lexer.l"
1615 {yylval.yint = F_MIE; return(NUMBER); }
1616 YY_BREAK
1617 case 66:
1618 YY_RULE_SETUP
1619 #line 160 "pl-lexer.l"
1620 {yylval.yint = F_BRE; return(NUMBER); }
1621 YY_BREAK
1622 case 67:
1623 YY_RULE_SETUP
1624 #line 161 "pl-lexer.l"
1625 {yylval.yint = F_BIE; return(NUMBER); }
1626 YY_BREAK
1627 case 68:
1628 YY_RULE_SETUP
1629 #line 162 "pl-lexer.l"
1630 {yylval.yint = F_LRE; return(NUMBER); }
1631 YY_BREAK
1632 case 69:
1633 YY_RULE_SETUP
1634 #line 163 "pl-lexer.l"
1635 {yylval.yint = F_LIE; return(NUMBER); }
1636 YY_BREAK
1637 case 70:
1638 YY_RULE_SETUP
1639 #line 165 "pl-lexer.l"
1640 {yylval.yint = P_SLANT; return(NAMEDPARAMETER); }
1641 YY_BREAK
1642 case 71:
1643 YY_RULE_SETUP
1644 #line 166 "pl-lexer.l"
1645 {yylval.yint = P_SPACE; return(NAMEDPARAMETER); }
1646 YY_BREAK
1647 case 72:
1648 YY_RULE_SETUP
1649 #line 167 "pl-lexer.l"
1650 {yylval.yint = P_STRETCH; return(NAMEDPARAMETER); }
1651 YY_BREAK
1652 case 73:
1653 YY_RULE_SETUP
1654 #line 168 "pl-lexer.l"
1655 {yylval.yint = P_SHRINK; return(NAMEDPARAMETER); }
1656 YY_BREAK
1657 case 74:
1658 YY_RULE_SETUP
1659 #line 169 "pl-lexer.l"
1660 {yylval.yint = P_XHEIGHT; return(NAMEDPARAMETER); }
1661 YY_BREAK
1662 case 75:
1663 YY_RULE_SETUP
1664 #line 170 "pl-lexer.l"
1665 {yylval.yint = P_QUAD; return(NAMEDPARAMETER); }
1666 YY_BREAK
1667 case 76:
1668 YY_RULE_SETUP
1669 #line 171 "pl-lexer.l"
1670 {yylval.yint = P_EXTRASPACE; return(NAMEDPARAMETER); }
1671 YY_BREAK
1672 case 77:
1673 YY_RULE_SETUP
1674 #line 172 "pl-lexer.l"
1675 {yylval.yint = P_NUM1; return(NAMEDPARAMETER); }
1676 YY_BREAK
1677 case 78:
1678 YY_RULE_SETUP
1679 #line 173 "pl-lexer.l"
1680 {yylval.yint = P_NUM2; return(NAMEDPARAMETER); }
1681 YY_BREAK
1682 case 79:
1683 YY_RULE_SETUP
1684 #line 174 "pl-lexer.l"
1685 {yylval.yint = P_NUM3; return(NAMEDPARAMETER); }
1686 YY_BREAK
1687 case 80:
1688 YY_RULE_SETUP
1689 #line 175 "pl-lexer.l"
1690 {yylval.yint = P_DENOM1; return(NAMEDPARAMETER); }
1691 YY_BREAK
1692 case 81:
1693 YY_RULE_SETUP
1694 #line 176 "pl-lexer.l"
1695 {yylval.yint = P_DENOM2; return(NAMEDPARAMETER); }
1696 YY_BREAK
1697 case 82:
1698 YY_RULE_SETUP
1699 #line 177 "pl-lexer.l"
1700 {yylval.yint = P_SUP1; return(NAMEDPARAMETER); }
1701 YY_BREAK
1702 case 83:
1703 YY_RULE_SETUP
1704 #line 178 "pl-lexer.l"
1705 {yylval.yint = P_SUP2; return(NAMEDPARAMETER); }
1706 YY_BREAK
1707 case 84:
1708 YY_RULE_SETUP
1709 #line 179 "pl-lexer.l"
1710 {yylval.yint = P_SUP3; return(NAMEDPARAMETER); }
1711 YY_BREAK
1712 case 85:
1713 YY_RULE_SETUP
1714 #line 180 "pl-lexer.l"
1715 {yylval.yint = P_SUB1; return(NAMEDPARAMETER); }
1716 YY_BREAK
1717 case 86:
1718 YY_RULE_SETUP
1719 #line 181 "pl-lexer.l"
1720 {yylval.yint = P_SUB2; return(NAMEDPARAMETER); }
1721 YY_BREAK
1722 case 87:
1723 YY_RULE_SETUP
1724 #line 182 "pl-lexer.l"
1725 {yylval.yint = P_SUPDROP; return(NAMEDPARAMETER); }
1726 YY_BREAK
1727 case 88:
1728 YY_RULE_SETUP
1729 #line 183 "pl-lexer.l"
1730 {yylval.yint = P_SUBDROP; return(NAMEDPARAMETER); }
1731 YY_BREAK
1732 case 89:
1733 YY_RULE_SETUP
1734 #line 184 "pl-lexer.l"
1735 {yylval.yint = P_DELIM1; return(NAMEDPARAMETER); }
1736 YY_BREAK
1737 case 90:
1738 YY_RULE_SETUP
1739 #line 185 "pl-lexer.l"
1740 {yylval.yint = P_DELIM2; return(NAMEDPARAMETER); }
1741 YY_BREAK
1742 case 91:
1743 YY_RULE_SETUP
1744 #line 186 "pl-lexer.l"
1745 {yylval.yint = P_AXISHEIGHT; return(NAMEDPARAMETER); }
1746 YY_BREAK
1747 case 92:
1748 YY_RULE_SETUP
1749 #line 188 "pl-lexer.l"
1750 {yylval.yint = P_DEFAULTRULETHICKNESS;
1751 return(NAMEDPARAMETER); }
1752 YY_BREAK
1753 case 93:
1754 YY_RULE_SETUP
1755 #line 190 "pl-lexer.l"
1756 {yylval.yint = P_BIGOPSPACING1; return(NAMEDPARAMETER); }
1757 YY_BREAK
1758 case 94:
1759 YY_RULE_SETUP
1760 #line 191 "pl-lexer.l"
1761 {yylval.yint = P_BIGOPSPACING2; return(NAMEDPARAMETER); }
1762 YY_BREAK
1763 case 95:
1764 YY_RULE_SETUP
1765 #line 192 "pl-lexer.l"
1766 {yylval.yint = P_BIGOPSPACING3; return(NAMEDPARAMETER); }
1767 YY_BREAK
1768 case 96:
1769 YY_RULE_SETUP
1770 #line 193 "pl-lexer.l"
1771 {yylval.yint = P_BIGOPSPACING4; return(NAMEDPARAMETER); }
1772 YY_BREAK
1773 case 97:
1774 YY_RULE_SETUP
1775 #line 194 "pl-lexer.l"
1776 {yylval.yint = P_BIGOPSPACING5; return(NAMEDPARAMETER); }
1777 YY_BREAK
1778 case 98:
1779 YY_RULE_SETUP
1780 #line 196 "pl-lexer.l"
1781 {return(MAPFONT); }
1782 YY_BREAK
1783 case 99:
1784 YY_RULE_SETUP
1785 #line 197 "pl-lexer.l"
1786 {return(FONTCHECKSUM); }
1787 YY_BREAK
1788 case 100:
1789 YY_RULE_SETUP
1790 #line 198 "pl-lexer.l"
1791 {return(FONTAT); }
1792 YY_BREAK
1793 case 101:
1794 YY_RULE_SETUP
1795 #line 199 "pl-lexer.l"
1796 {return(FONTDSIZE); }
1797 YY_BREAK
1798 case 102:
1799 YY_RULE_SETUP
1800 #line 200 "pl-lexer.l"
1801 {return(MAP); }
1802 YY_BREAK
1803 case 103:
1804 YY_RULE_SETUP
1805 #line 201 "pl-lexer.l"
1806 {return(SELECTFONT); }
1807 YY_BREAK
1808 case 104:
1809 YY_RULE_SETUP
1810 #line 202 "pl-lexer.l"
1811 {return(SETCHAR); }
1812 YY_BREAK
1813 case 105:
1814 YY_RULE_SETUP
1815 #line 203 "pl-lexer.l"
1816 {return(SETRULE); }
1817 YY_BREAK
1818 case 106:
1819 YY_RULE_SETUP
1820 #line 204 "pl-lexer.l"
1821 {return(PUSH); }
1822 YY_BREAK
1823 case 107:
1824 YY_RULE_SETUP
1825 #line 205 "pl-lexer.l"
1826 {return(POP); }
1827 YY_BREAK
1828 case 108:
1829 YY_RULE_SETUP
1830 #line 207 "pl-lexer.l"
1831 {yylval.yint = M_RIGHT; return(MOVE); }
1832 YY_BREAK
1833 case 109:
1834 YY_RULE_SETUP
1835 #line 208 "pl-lexer.l"
1836 {yylval.yint = M_LEFT; return(MOVE); }
1837 YY_BREAK
1838 case 110:
1839 YY_RULE_SETUP
1840 #line 209 "pl-lexer.l"
1841 {yylval.yint = M_UP; return(MOVE); }
1842 YY_BREAK
1843 case 111:
1844 YY_RULE_SETUP
1845 #line 210 "pl-lexer.l"
1846 {yylval.yint = M_DOWN; return(MOVE); }
1847 YY_BREAK
1848 case 112:
1849 YY_RULE_SETUP
1850 #line 212 "pl-lexer.l"
1851 return(OFMLEVEL);
1852 YY_BREAK
1853 case 113:
1854 YY_RULE_SETUP
1855 #line 213 "pl-lexer.l"
1856 {yylval.yint = ACC_TOP; return(ACCENT); }
1857 YY_BREAK
1858 case 114:
1859 YY_RULE_SETUP
1860 #line 214 "pl-lexer.l"
1861 {yylval.yint = ACC_MID; return(ACCENT); }
1862 YY_BREAK
1863 case 115:
1864 YY_RULE_SETUP
1865 #line 215 "pl-lexer.l"
1866 {yylval.yint = ACC_BOT; return(ACCENT); }
1867 YY_BREAK
1868 case 116:
1869 YY_RULE_SETUP
1870 #line 217 "pl-lexer.l"
1871 {yylval.yint = DIR_ORD+DIR_TL; return(FONTDIR);}
1872 YY_BREAK
1873 case 117:
1874 YY_RULE_SETUP
1875 #line 218 "pl-lexer.l"
1876 {yylval.yint = DIR_ORD+DIR_LT; return(FONTDIR);}
1877 YY_BREAK
1878 case 118:
1879 YY_RULE_SETUP
1880 #line 219 "pl-lexer.l"
1881 {yylval.yint = DIR_ORD+DIR_TR; return(FONTDIR);}
1882 YY_BREAK
1883 case 119:
1884 YY_RULE_SETUP
1885 #line 220 "pl-lexer.l"
1886 {yylval.yint = DIR_ORD+DIR_LB; return(FONTDIR);}
1887 YY_BREAK
1888 case 120:
1889 YY_RULE_SETUP
1890 #line 221 "pl-lexer.l"
1891 {yylval.yint = DIR_ORD+DIR_BL; return(FONTDIR);}
1892 YY_BREAK
1893 case 121:
1894 YY_RULE_SETUP
1895 #line 222 "pl-lexer.l"
1896 {yylval.yint = DIR_ORD+DIR_RT; return(FONTDIR);}
1897 YY_BREAK
1898 case 122:
1899 YY_RULE_SETUP
1900 #line 223 "pl-lexer.l"
1901 {yylval.yint = DIR_ORD+DIR_BR; return(FONTDIR);}
1902 YY_BREAK
1903 case 123:
1904 YY_RULE_SETUP
1905 #line 224 "pl-lexer.l"
1906 {yylval.yint = DIR_ORD+DIR_RB; return(FONTDIR);}
1907 YY_BREAK
1908 case 124:
1909 YY_RULE_SETUP
1910 #line 225 "pl-lexer.l"
1911 {yylval.yint = DIR_NAT+DIR_TL; return(FONTDIR);}
1912 YY_BREAK
1913 case 125:
1914 YY_RULE_SETUP
1915 #line 226 "pl-lexer.l"
1916 {yylval.yint = DIR_NAT+DIR_LT; return(FONTDIR);}
1917 YY_BREAK
1918 case 126:
1919 YY_RULE_SETUP
1920 #line 227 "pl-lexer.l"
1921 {yylval.yint = DIR_NAT+DIR_TR; return(FONTDIR);}
1922 YY_BREAK
1923 case 127:
1924 YY_RULE_SETUP
1925 #line 228 "pl-lexer.l"
1926 {yylval.yint = DIR_NAT+DIR_LB; return(FONTDIR);}
1927 YY_BREAK
1928 case 128:
1929 YY_RULE_SETUP
1930 #line 229 "pl-lexer.l"
1931 {yylval.yint = DIR_NAT+DIR_BL; return(FONTDIR);}
1932 YY_BREAK
1933 case 129:
1934 YY_RULE_SETUP
1935 #line 230 "pl-lexer.l"
1936 {yylval.yint = DIR_NAT+DIR_RT; return(FONTDIR);}
1937 YY_BREAK
1938 case 130:
1939 YY_RULE_SETUP
1940 #line 231 "pl-lexer.l"
1941 {yylval.yint = DIR_NAT+DIR_BR; return(FONTDIR);}
1942 YY_BREAK
1943 case 131:
1944 YY_RULE_SETUP
1945 #line 232 "pl-lexer.l"
1946 {yylval.yint = DIR_NAT+DIR_RB; return(FONTDIR);}
1947 YY_BREAK
1948 /* for compatibility with the omegaware versions */
1949 case 132:
1950 YY_RULE_SETUP
1951 #line 234 "pl-lexer.l"
1952 {yylval.yint = DIR_NAT+DIR_TL; return(FONTDIR);}
1953 YY_BREAK
1954 case 133:
1955 YY_RULE_SETUP
1956 #line 235 "pl-lexer.l"
1957 {yylval.yint = DIR_NAT+DIR_LT; return(FONTDIR);}
1958 YY_BREAK
1959 case 134:
1960 YY_RULE_SETUP
1961 #line 236 "pl-lexer.l"
1962 {yylval.yint = DIR_NAT+DIR_TR; return(FONTDIR);}
1963 YY_BREAK
1964 case 135:
1965 YY_RULE_SETUP
1966 #line 237 "pl-lexer.l"
1967 {yylval.yint = DIR_NAT+DIR_LB; return(FONTDIR);}
1968 YY_BREAK
1969 case 136:
1970 YY_RULE_SETUP
1971 #line 238 "pl-lexer.l"
1972 {yylval.yint = DIR_NAT+DIR_BL; return(FONTDIR);}
1973 YY_BREAK
1974 case 137:
1975 YY_RULE_SETUP
1976 #line 239 "pl-lexer.l"
1977 {yylval.yint = DIR_NAT+DIR_RT; return(FONTDIR);}
1978 YY_BREAK
1979 case 138:
1980 YY_RULE_SETUP
1981 #line 240 "pl-lexer.l"
1982 {yylval.yint = DIR_NAT+DIR_BR; return(FONTDIR);}
1983 YY_BREAK
1984 case 139:
1985 YY_RULE_SETUP
1986 #line 241 "pl-lexer.l"
1987 {yylval.yint = DIR_NAT+DIR_RB; return(FONTDIR);}
1988 YY_BREAK
1989 case 140:
1990 YY_RULE_SETUP
1991 #line 243 "pl-lexer.l"
1992 return(FONTIVALUE);
1993 YY_BREAK
1994 case 141:
1995 YY_RULE_SETUP
1996 #line 244 "pl-lexer.l"
1997 return(FONTFVALUE);
1998 YY_BREAK
1999 case 142:
2000 YY_RULE_SETUP
2001 #line 245 "pl-lexer.l"
2002 return(FONTMVALUE);
2003 YY_BREAK
2004 case 143:
2005 YY_RULE_SETUP
2006 #line 246 "pl-lexer.l"
2007 return(FONTPENALTY);
2008 YY_BREAK
2009 case 144:
2010 YY_RULE_SETUP
2011 #line 247 "pl-lexer.l"
2012 return(FONTRULE);
2013 YY_BREAK
2014 case 145:
2015 YY_RULE_SETUP
2016 #line 248 "pl-lexer.l"
2017 return(FONTGLUE);
2018 YY_BREAK
2019 case 146:
2020 YY_RULE_SETUP
2021 #line 250 "pl-lexer.l"
2022 return(IVALUE);
2023 YY_BREAK
2024 case 147:
2025 YY_RULE_SETUP
2026 #line 251 "pl-lexer.l"
2027 return(FVALUE);
2028 YY_BREAK
2029 case 148:
2030 YY_RULE_SETUP
2031 #line 252 "pl-lexer.l"
2032 return(MVALUE);
2033 YY_BREAK
2034 case 149:
2035 YY_RULE_SETUP
2036 #line 253 "pl-lexer.l"
2037 return(PENALTY);
2038 YY_BREAK
2039 case 150:
2040 YY_RULE_SETUP
2041 #line 254 "pl-lexer.l"
2042 return(RULE);
2043 YY_BREAK
2044 case 151:
2045 YY_RULE_SETUP
2046 #line 255 "pl-lexer.l"
2047 return(GLUE);
2048 YY_BREAK
2049 case 152:
2050 YY_RULE_SETUP
2051 #line 257 "pl-lexer.l"
2052 return(IVALUEVAL);
2053 YY_BREAK
2054 case 153:
2055 YY_RULE_SETUP
2056 #line 258 "pl-lexer.l"
2057 return(FVALUEVAL);
2058 YY_BREAK
2059 case 154:
2060 YY_RULE_SETUP
2061 #line 259 "pl-lexer.l"
2062 return(MVALUEVAL);
2063 YY_BREAK
2064 case 155:
2065 YY_RULE_SETUP
2066 #line 260 "pl-lexer.l"
2067 return(PENALTYVAL);
2068 YY_BREAK
2069 case 156:
2070 YY_RULE_SETUP
2071 #line 262 "pl-lexer.l"
2072 { yylval.yint = RULE_WD; return(RULEMEASURE); }
2073 YY_BREAK
2074 case 157:
2075 YY_RULE_SETUP
2076 #line 263 "pl-lexer.l"
2077 { yylval.yint = RULE_HT; return(RULEMEASURE); }
2078 YY_BREAK
2079 case 158:
2080 YY_RULE_SETUP
2081 #line 264 "pl-lexer.l"
2082 { yylval.yint = RULE_DP; return(RULEMEASURE); }
2083 YY_BREAK
2084 case 159:
2085 YY_RULE_SETUP
2086 #line 266 "pl-lexer.l"
2087 return(GLUEWD);
2088 YY_BREAK
2089 case 160:
2090 YY_RULE_SETUP
2091 #line 267 "pl-lexer.l"
2092 { yylval.yint = GLUE_STRETCH; return(GLUESHRINKSTRETCH); }
2093 YY_BREAK
2094 case 161:
2095 YY_RULE_SETUP
2096 #line 268 "pl-lexer.l"
2097 { yylval.yint = GLUE_SHRINK; return(GLUESHRINKSTRETCH); }
2098 YY_BREAK
2099 case 162:
2100 YY_RULE_SETUP
2101 #line 270 "pl-lexer.l"
2102 return(GLUETYPE);
2103 YY_BREAK
2104 case 163:
2105 YY_RULE_SETUP
2106 #line 271 "pl-lexer.l"
2107 return(GLUERULE);
2108 YY_BREAK
2109 case 164:
2110 YY_RULE_SETUP
2111 #line 272 "pl-lexer.l"
2112 return(GLUECHAR);
2113 YY_BREAK
2114 case 165:
2115 YY_RULE_SETUP
2116 #line 274 "pl-lexer.l"
2117 return(CHARIVALUE);
2118 YY_BREAK
2119 case 166:
2120 YY_RULE_SETUP
2121 #line 275 "pl-lexer.l"
2122 return(CHARFVALUE);
2123 YY_BREAK
2124 case 167:
2125 YY_RULE_SETUP
2126 #line 276 "pl-lexer.l"
2127 return(CHARMVALUE);
2128 YY_BREAK
2129 case 168:
2130 YY_RULE_SETUP
2131 #line 277 "pl-lexer.l"
2132 return(CHARPENALTY);
2133 YY_BREAK
2134 case 169:
2135 YY_RULE_SETUP
2136 #line 278 "pl-lexer.l"
2137 return(CHARRULE);
2138 YY_BREAK
2139 case 170:
2140 YY_RULE_SETUP
2141 #line 279 "pl-lexer.l"
2142 return(CHARGLUE);
2143 YY_BREAK
2144 case 171:
2145 YY_RULE_SETUP
2146 #line 281 "pl-lexer.l"
2147 return(CKRN);
2148 YY_BREAK
2149 case 172:
2150 YY_RULE_SETUP
2151 #line 282 "pl-lexer.l"
2152 return(CGLUE);
2153 YY_BREAK
2154 case 173:
2155 YY_RULE_SETUP
2156 #line 283 "pl-lexer.l"
2157 return(CPENALTY);
2158 YY_BREAK
2159 case 174:
2160 YY_RULE_SETUP
2161 #line 284 "pl-lexer.l"
2162 return(CPENGLUE);
2163 YY_BREAK
2164 case 175:
2165 YY_RULE_SETUP
2166 #line 285 "pl-lexer.l"
2167 return(CLABEL);
2168 YY_BREAK
2169 case 176:
2170 YY_RULE_SETUP
2171 #line 287 "pl-lexer.l"
2172 return(CHARREPEAT);
2173 YY_BREAK
2174 case 177:
2175 YY_RULE_SETUP
2176 #line 290 "pl-lexer.l"
2177 {yylval.yint = O_FILLL; return(GLUEORDER); }
2178 YY_BREAK
2179 case 178:
2180 YY_RULE_SETUP
2181 #line 291 "pl-lexer.l"
2182 {yylval.yint = O_FILL; return(GLUEORDER); }
2183 YY_BREAK
2184 case 179:
2185 YY_RULE_SETUP
2186 #line 292 "pl-lexer.l"
2187 {yylval.yint = O_FIL; return(GLUEORDER); }
2188 YY_BREAK
2189 case 180:
2190 YY_RULE_SETUP
2191 #line 293 "pl-lexer.l"
2192 {yylval.yint = O_FI; return(GLUEORDER); }
2193 YY_BREAK
2194 case 181:
2195 YY_RULE_SETUP
2196 #line 294 "pl-lexer.l"
2197 {yylval.yint = O_UNIT; return(GLUEORDER); }
2198 YY_BREAK
2199 case 182:
2200 YY_RULE_SETUP
2201 #line 296 "pl-lexer.l"
2202 {yylval.yint = K_NORMAL; return(GLUEKIND); }
2203 YY_BREAK
2204 case 183:
2205 YY_RULE_SETUP
2206 #line 297 "pl-lexer.l"
2207 {yylval.yint = K_ALEADERS; return(GLUEKIND); }
2208 YY_BREAK
2209 case 184:
2210 YY_RULE_SETUP
2211 #line 298 "pl-lexer.l"
2212 {yylval.yint = K_CLEADERS; return(GLUEKIND); }
2213 YY_BREAK
2214 case 185:
2215 YY_RULE_SETUP
2216 #line 299 "pl-lexer.l"
2217 {yylval.yint = K_XLEADERS; return(GLUEKIND); }
2218 YY_BREAK
2219 case 186:
2220 YY_RULE_SETUP
2221 #line 301 "pl-lexer.l"
2222 {yylval.yint = C_SECWD; return(CHARMEASURE); }
2223 YY_BREAK
2224 case 187:
2225 YY_RULE_SETUP
2226 #line 302 "pl-lexer.l"
2227 {yylval.yint = C_SECHT; return(CHARMEASURE); }
2228 YY_BREAK
2229 case 188:
2230 YY_RULE_SETUP
2231 #line 303 "pl-lexer.l"
2232 {yylval.yint = C_SECDP; return(CHARMEASURE); }
2233 YY_BREAK
2234 case 189:
2235 YY_RULE_SETUP
2236 #line 304 "pl-lexer.l"
2237 {yylval.yint = C_SECIC; return(CHARMEASURE); }
2238 YY_BREAK
2239 case 190:
2240 YY_RULE_SETUP
2241 #line 306 "pl-lexer.l"
2242 {yylval.yint = C_P_TOPAXIS; return(CHARMEASURE); }
2243 YY_BREAK
2244 case 191:
2245 YY_RULE_SETUP
2246 #line 307 "pl-lexer.l"
2247 {yylval.yint = C_P_TOPAXISBIs; return(CHARMEASURE); }
2248 YY_BREAK
2249 case 192:
2250 YY_RULE_SETUP
2251 #line 308 "pl-lexer.l"
2252 {yylval.yint = C_P_BOTAXIS; return(CHARMEASURE); }
2253 YY_BREAK
2254 case 193:
2255 YY_RULE_SETUP
2256 #line 309 "pl-lexer.l"
2257 {yylval.yint = C_P_BOTAXISBIS; return(CHARMEASURE); }
2258 YY_BREAK
2259 case 194:
2260 YY_RULE_SETUP
2261 #line 310 "pl-lexer.l"
2262 {yylval.yint = C_P_MIDHOR; return(CHARMEASURE); }
2263 YY_BREAK
2264 case 195:
2265 YY_RULE_SETUP
2266 #line 311 "pl-lexer.l"
2267 {yylval.yint = C_P_MIDVERT; return(CHARMEASURE); }
2268 YY_BREAK
2269 case 196:
2270 YY_RULE_SETUP
2271 #line 312 "pl-lexer.l"
2272 {yylval.yint = C_P_BASESLANT; return(CHARMEASURE); }
2273 YY_BREAK
2274 case 197:
2275 YY_RULE_SETUP
2276 #line 314 "pl-lexer.l"
2277 {yylval.yint = C_S_TOPAXIS; return(CHARMEASURE); }
2278 YY_BREAK
2279 case 198:
2280 YY_RULE_SETUP
2281 #line 315 "pl-lexer.l"
2282 {yylval.yint = C_S_TOPAXISBIs; return(CHARMEASURE); }
2283 YY_BREAK
2284 case 199:
2285 YY_RULE_SETUP
2286 #line 316 "pl-lexer.l"
2287 {yylval.yint = C_S_BOTAXIS; return(CHARMEASURE); }
2288 YY_BREAK
2289 case 200:
2290 YY_RULE_SETUP
2291 #line 317 "pl-lexer.l"
2292 {yylval.yint = C_S_BOTAXISBIS; return(CHARMEASURE); }
2293 YY_BREAK
2294 case 201:
2295 YY_RULE_SETUP
2296 #line 318 "pl-lexer.l"
2297 {yylval.yint = C_S_MIDHOR; return(CHARMEASURE); }
2298 YY_BREAK
2299 case 202:
2300 YY_RULE_SETUP
2301 #line 319 "pl-lexer.l"
2302 {yylval.yint = C_S_MIDVERT; return(CHARMEASURE); }
2303 YY_BREAK
2304 case 203:
2305 YY_RULE_SETUP
2306 #line 320 "pl-lexer.l"
2307 {yylval.yint = C_S_BASESLANT; return(CHARMEASURE); }
2308 YY_BREAK
2309 case 204:
2310 YY_RULE_SETUP
2311 #line 322 "pl-lexer.l"
2312 {lex_error_1("unexpected character (%x); ignored",
2313 yytext[0]);}
2314 YY_BREAK
2315 case 205:
2316 YY_RULE_SETUP
2317 #line 324 "pl-lexer.l"
2318 ECHO;
2319 YY_BREAK
2320 #line 2321 "pl-lexer.c"
2321 case YY_STATE_EOF(INITIAL):
2322 yyterminate();
2323
2324 case YY_END_OF_BUFFER:
2325 {
2326 /* Amount of text matched not including the EOB char. */
2327 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2328
2329 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2330 *yy_cp = (yy_hold_char);
2331 YY_RESTORE_YY_MORE_OFFSET
2332
2333 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2334 {
2335 /* We're scanning a new file or input source. It's
2336 * possible that this happened because the user
2337 * just pointed yyin at a new source and called
2338 * yylex(). If so, then we have to assure
2339 * consistency between YY_CURRENT_BUFFER and our
2340 * globals. Here is the right place to do so, because
2341 * this is the first action (other than possibly a
2342 * back-up) that will match for the new input source.
2343 */
2344 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2345 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2346 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2347 }
2348
2349 /* Note that here we test for yy_c_buf_p "<=" to the position
2350 * of the first EOB in the buffer, since yy_c_buf_p will
2351 * already have been incremented past the NUL character
2352 * (since all states make transitions on EOB to the
2353 * end-of-buffer state). Contrast this with the test
2354 * in input().
2355 */
2356 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2357 { /* This was really a NUL. */
2358 yy_state_type yy_next_state;
2359
2360 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2361
2362 yy_current_state = yy_get_previous_state( );
2363
2364 /* Okay, we're now positioned to make the NUL
2365 * transition. We couldn't have
2366 * yy_get_previous_state() go ahead and do it
2367 * for us because it doesn't know how to deal
2368 * with the possibility of jamming (and we don't
2369 * want to build jamming into it because then it
2370 * will run more slowly).
2371 */
2372
2373 yy_next_state = yy_try_NUL_trans( yy_current_state );
2374
2375 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2376
2377 if ( yy_next_state )
2378 {
2379 /* Consume the NUL. */
2380 yy_cp = ++(yy_c_buf_p);
2381 yy_current_state = yy_next_state;
2382 goto yy_match;
2383 }
2384
2385 else
2386 {
2387 yy_cp = (yy_last_accepting_cpos);
2388 yy_current_state = (yy_last_accepting_state);
2389 goto yy_find_action;
2390 }
2391 }
2392
2393 else switch ( yy_get_next_buffer( ) )
2394 {
2395 case EOB_ACT_END_OF_FILE:
2396 {
2397 (yy_did_buffer_switch_on_eof) = 0;
2398
2399 if ( yywrap( ) )
2400 {
2401 /* Note: because we've taken care in
2402 * yy_get_next_buffer() to have set up
2403 * yytext, we can now set up
2404 * yy_c_buf_p so that if some total
2405 * hoser (like flex itself) wants to
2406 * call the scanner after we return the
2407 * YY_NULL, it'll still work - another
2408 * YY_NULL will get returned.
2409 */
2410 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2411
2412 yy_act = YY_STATE_EOF(YY_START);
2413 goto do_action;
2414 }
2415
2416 else
2417 {
2418 if ( ! (yy_did_buffer_switch_on_eof) )
2419 YY_NEW_FILE;
2420 }
2421 break;
2422 }
2423
2424 case EOB_ACT_CONTINUE_SCAN:
2425 (yy_c_buf_p) =
2426 (yytext_ptr) + yy_amount_of_matched_text;
2427
2428 yy_current_state = yy_get_previous_state( );
2429
2430 yy_cp = (yy_c_buf_p);
2431 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2432 goto yy_match;
2433
2434 case EOB_ACT_LAST_MATCH:
2435 (yy_c_buf_p) =
2436 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2437
2438 yy_current_state = yy_get_previous_state( );
2439
2440 yy_cp = (yy_c_buf_p);
2441 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2442 goto yy_find_action;
2443 }
2444 break;
2445 }
2446
2447 default:
2448 YY_FATAL_ERROR(
2449 "fatal flex scanner internal error--no action found" );
2450 } /* end of action switch */
2451 } /* end of scanning one token */
2452 } /* end of user's declarations */
2453 } /* end of yylex */
2454
2455 /* yy_get_next_buffer - try to read in a new buffer
2456 *
2457 * Returns a code representing an action:
2458 * EOB_ACT_LAST_MATCH -
2459 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2460 * EOB_ACT_END_OF_FILE - end of file
2461 */
yy_get_next_buffer(void)2462 static int yy_get_next_buffer (void)
2463 {
2464 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2465 register char *source = (yytext_ptr);
2466 register int number_to_move, i;
2467 int ret_val;
2468
2469 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2470 YY_FATAL_ERROR(
2471 "fatal flex scanner internal error--end of buffer missed" );
2472
2473 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2474 { /* Don't try to fill the buffer, so this is an EOF. */
2475 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2476 {
2477 /* We matched a single character, the EOB, so
2478 * treat this as a final EOF.
2479 */
2480 return EOB_ACT_END_OF_FILE;
2481 }
2482
2483 else
2484 {
2485 /* We matched some text prior to the EOB, first
2486 * process it.
2487 */
2488 return EOB_ACT_LAST_MATCH;
2489 }
2490 }
2491
2492 /* Try to read more data. */
2493
2494 /* First move last chars to start of buffer. */
2495 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2496
2497 for ( i = 0; i < number_to_move; ++i )
2498 *(dest++) = *(source++);
2499
2500 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2501 /* don't do the read, it's not guaranteed to return an EOF,
2502 * just force an EOF
2503 */
2504 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2505
2506 else
2507 {
2508 yy_size_t num_to_read =
2509 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2510
2511 while ( num_to_read <= 0 )
2512 { /* Not enough room in the buffer - grow it. */
2513
2514 /* just a shorter name for the current buffer */
2515 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
2516
2517 int yy_c_buf_p_offset =
2518 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2519
2520 if ( b->yy_is_our_buffer )
2521 {
2522 yy_size_t new_size = b->yy_buf_size * 2;
2523
2524 if ( new_size <= 0 )
2525 b->yy_buf_size += b->yy_buf_size / 8;
2526 else
2527 b->yy_buf_size *= 2;
2528
2529 b->yy_ch_buf = (char *)
2530 /* Include room in for 2 EOB chars. */
2531 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
2532 }
2533 else
2534 /* Can't grow it, we don't own it. */
2535 b->yy_ch_buf = 0;
2536
2537 if ( ! b->yy_ch_buf )
2538 YY_FATAL_ERROR(
2539 "fatal error - scanner input buffer overflow" );
2540
2541 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2542
2543 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2544 number_to_move - 1;
2545
2546 }
2547
2548 if ( num_to_read > YY_READ_BUF_SIZE )
2549 num_to_read = YY_READ_BUF_SIZE;
2550
2551 /* Read in more data. */
2552 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2553 (yy_n_chars), num_to_read );
2554
2555 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2556 }
2557
2558 if ( (yy_n_chars) == 0 )
2559 {
2560 if ( number_to_move == YY_MORE_ADJ )
2561 {
2562 ret_val = EOB_ACT_END_OF_FILE;
2563 yyrestart(yyin );
2564 }
2565
2566 else
2567 {
2568 ret_val = EOB_ACT_LAST_MATCH;
2569 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2570 YY_BUFFER_EOF_PENDING;
2571 }
2572 }
2573
2574 else
2575 ret_val = EOB_ACT_CONTINUE_SCAN;
2576
2577 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2578 /* Extend the array by 50%, plus the number we really need. */
2579 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2580 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
2581 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2582 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2583 }
2584
2585 (yy_n_chars) += number_to_move;
2586 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2587 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2588
2589 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2590
2591 return ret_val;
2592 }
2593
2594 /* yy_get_previous_state - get the state just before the EOB char was reached */
2595
yy_get_previous_state(void)2596 static yy_state_type yy_get_previous_state (void)
2597 {
2598 register yy_state_type yy_current_state;
2599 register char *yy_cp;
2600
2601 yy_current_state = (yy_start);
2602
2603 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2604 {
2605 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2606 if ( yy_accept[yy_current_state] )
2607 {
2608 (yy_last_accepting_state) = yy_current_state;
2609 (yy_last_accepting_cpos) = yy_cp;
2610 }
2611 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2612 {
2613 yy_current_state = (int) yy_def[yy_current_state];
2614 if ( yy_current_state >= 800 )
2615 yy_c = yy_meta[(unsigned int) yy_c];
2616 }
2617 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2618 }
2619
2620 return yy_current_state;
2621 }
2622
2623 /* yy_try_NUL_trans - try to make a transition on the NUL character
2624 *
2625 * synopsis
2626 * next_state = yy_try_NUL_trans( current_state );
2627 */
yy_try_NUL_trans(yy_state_type yy_current_state)2628 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
2629 {
2630 register int yy_is_jam;
2631 register char *yy_cp = (yy_c_buf_p);
2632
2633 register YY_CHAR yy_c = 1;
2634 if ( yy_accept[yy_current_state] )
2635 {
2636 (yy_last_accepting_state) = yy_current_state;
2637 (yy_last_accepting_cpos) = yy_cp;
2638 }
2639 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2640 {
2641 yy_current_state = (int) yy_def[yy_current_state];
2642 if ( yy_current_state >= 800 )
2643 yy_c = yy_meta[(unsigned int) yy_c];
2644 }
2645 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2646 yy_is_jam = (yy_current_state == 799);
2647
2648 return yy_is_jam ? 0 : yy_current_state;
2649 }
2650
yyunput(int c,register char * yy_bp)2651 static void yyunput (int c, register char * yy_bp )
2652 {
2653 register char *yy_cp;
2654
2655 yy_cp = (yy_c_buf_p);
2656
2657 /* undo effects of setting up yytext */
2658 *yy_cp = (yy_hold_char);
2659
2660 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2661 { /* need to shift things up to make room */
2662 /* +2 for EOB chars. */
2663 register yy_size_t number_to_move = (yy_n_chars) + 2;
2664 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2665 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2666 register char *source =
2667 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2668
2669 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2670 *--dest = *--source;
2671
2672 yy_cp += (int) (dest - source);
2673 yy_bp += (int) (dest - source);
2674 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2675 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2676
2677 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2678 YY_FATAL_ERROR( "flex scanner push-back overflow" );
2679 }
2680
2681 *--yy_cp = (char) c;
2682
2683 if ( c == '\n' ){
2684 --yylineno;
2685 }
2686
2687 (yytext_ptr) = yy_bp;
2688 (yy_hold_char) = *yy_cp;
2689 (yy_c_buf_p) = yy_cp;
2690 }
2691
2692 #ifndef YY_NO_INPUT
2693 #ifdef __cplusplus
yyinput(void)2694 static int yyinput (void)
2695 #else
2696 static int input (void)
2697 #endif
2698
2699 {
2700 int c;
2701
2702 *(yy_c_buf_p) = (yy_hold_char);
2703
2704 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2705 {
2706 /* yy_c_buf_p now points to the character we want to return.
2707 * If this occurs *before* the EOB characters, then it's a
2708 * valid NUL; if not, then we've hit the end of the buffer.
2709 */
2710 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2711 /* This was really a NUL. */
2712 *(yy_c_buf_p) = '\0';
2713
2714 else
2715 { /* need more input */
2716 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2717 ++(yy_c_buf_p);
2718
2719 switch ( yy_get_next_buffer( ) )
2720 {
2721 case EOB_ACT_LAST_MATCH:
2722 /* This happens because yy_g_n_b()
2723 * sees that we've accumulated a
2724 * token and flags that we need to
2725 * try matching the token before
2726 * proceeding. But for input(),
2727 * there's no matching to consider.
2728 * So convert the EOB_ACT_LAST_MATCH
2729 * to EOB_ACT_END_OF_FILE.
2730 */
2731
2732 /* Reset buffer status. */
2733 yyrestart(yyin );
2734
2735 /*FALLTHROUGH*/
2736
2737 case EOB_ACT_END_OF_FILE:
2738 {
2739 if ( yywrap( ) )
2740 return EOF;
2741
2742 if ( ! (yy_did_buffer_switch_on_eof) )
2743 YY_NEW_FILE;
2744 #ifdef __cplusplus
2745 return yyinput();
2746 #else
2747 return input();
2748 #endif
2749 }
2750
2751 case EOB_ACT_CONTINUE_SCAN:
2752 (yy_c_buf_p) = (yytext_ptr) + offset;
2753 break;
2754 }
2755 }
2756 }
2757
2758 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2759 *(yy_c_buf_p) = '\0'; /* preserve yytext */
2760 (yy_hold_char) = *++(yy_c_buf_p);
2761
2762 if ( c == '\n' )
2763
2764 yylineno++;
2765 ;
2766
2767 return c;
2768 }
2769 #endif /* ifndef YY_NO_INPUT */
2770
2771 /** Immediately switch to a different input stream.
2772 * @param input_file A readable stream.
2773 *
2774 * @note This function does not reset the start condition to @c INITIAL .
2775 */
yyrestart(FILE * input_file)2776 void yyrestart (FILE * input_file )
2777 {
2778
2779 if ( ! YY_CURRENT_BUFFER ){
2780 yyensure_buffer_stack ();
2781 YY_CURRENT_BUFFER_LVALUE =
2782 yy_create_buffer(yyin,YY_BUF_SIZE );
2783 }
2784
2785 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2786 yy_load_buffer_state( );
2787 }
2788
2789 /** Switch to a different input buffer.
2790 * @param new_buffer The new input buffer.
2791 *
2792 */
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)2793 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
2794 {
2795
2796 /* TODO. We should be able to replace this entire function body
2797 * with
2798 * yypop_buffer_state();
2799 * yypush_buffer_state(new_buffer);
2800 */
2801 yyensure_buffer_stack ();
2802 if ( YY_CURRENT_BUFFER == new_buffer )
2803 return;
2804
2805 if ( YY_CURRENT_BUFFER )
2806 {
2807 /* Flush out information for old buffer. */
2808 *(yy_c_buf_p) = (yy_hold_char);
2809 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2810 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2811 }
2812
2813 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2814 yy_load_buffer_state( );
2815
2816 /* We don't actually know whether we did this switch during
2817 * EOF (yywrap()) processing, but the only time this flag
2818 * is looked at is after yywrap() is called, so it's safe
2819 * to go ahead and always set it.
2820 */
2821 (yy_did_buffer_switch_on_eof) = 1;
2822 }
2823
yy_load_buffer_state(void)2824 static void yy_load_buffer_state (void)
2825 {
2826 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2827 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2828 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2829 (yy_hold_char) = *(yy_c_buf_p);
2830 }
2831
2832 /** Allocate and initialize an input buffer state.
2833 * @param file A readable stream.
2834 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2835 *
2836 * @return the allocated buffer state.
2837 */
yy_create_buffer(FILE * file,int size)2838 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
2839 {
2840 YY_BUFFER_STATE b;
2841
2842 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
2843 if ( ! b )
2844 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2845
2846 b->yy_buf_size = size;
2847
2848 /* yy_ch_buf has to be 2 characters longer than the size given because
2849 * we need to put in 2 end-of-buffer characters.
2850 */
2851 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
2852 if ( ! b->yy_ch_buf )
2853 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2854
2855 b->yy_is_our_buffer = 1;
2856
2857 yy_init_buffer(b,file );
2858
2859 return b;
2860 }
2861
2862 /** Destroy the buffer.
2863 * @param b a buffer created with yy_create_buffer()
2864 *
2865 */
yy_delete_buffer(YY_BUFFER_STATE b)2866 void yy_delete_buffer (YY_BUFFER_STATE b )
2867 {
2868
2869 if ( ! b )
2870 return;
2871
2872 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2873 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2874
2875 if ( b->yy_is_our_buffer )
2876 yyfree((void *) b->yy_ch_buf );
2877
2878 yyfree((void *) b );
2879 }
2880
2881 /* Initializes or reinitializes a buffer.
2882 * This function is sometimes called more than once on the same buffer,
2883 * such as during a yyrestart() or at EOF.
2884 */
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)2885 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
2886
2887 {
2888 int oerrno = errno;
2889
2890 yy_flush_buffer(b );
2891
2892 b->yy_input_file = file;
2893 b->yy_fill_buffer = 1;
2894
2895 /* If b is the current buffer, then yy_init_buffer was _probably_
2896 * called from yyrestart() or through yy_get_next_buffer.
2897 * In that case, we don't want to reset the lineno or column.
2898 */
2899 if (b != YY_CURRENT_BUFFER){
2900 b->yy_bs_lineno = 1;
2901 b->yy_bs_column = 0;
2902 }
2903
2904 b->yy_is_interactive = 0;
2905
2906 errno = oerrno;
2907 }
2908
2909 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2910 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2911 *
2912 */
yy_flush_buffer(YY_BUFFER_STATE b)2913 void yy_flush_buffer (YY_BUFFER_STATE b )
2914 {
2915 if ( ! b )
2916 return;
2917
2918 b->yy_n_chars = 0;
2919
2920 /* We always need two end-of-buffer characters. The first causes
2921 * a transition to the end-of-buffer state. The second causes
2922 * a jam in that state.
2923 */
2924 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2925 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2926
2927 b->yy_buf_pos = &b->yy_ch_buf[0];
2928
2929 b->yy_at_bol = 1;
2930 b->yy_buffer_status = YY_BUFFER_NEW;
2931
2932 if ( b == YY_CURRENT_BUFFER )
2933 yy_load_buffer_state( );
2934 }
2935
2936 /** Pushes the new state onto the stack. The new state becomes
2937 * the current state. This function will allocate the stack
2938 * if necessary.
2939 * @param new_buffer The new state.
2940 *
2941 */
yypush_buffer_state(YY_BUFFER_STATE new_buffer)2942 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2943 {
2944 if (new_buffer == NULL)
2945 return;
2946
2947 yyensure_buffer_stack();
2948
2949 /* This block is copied from yy_switch_to_buffer. */
2950 if ( YY_CURRENT_BUFFER )
2951 {
2952 /* Flush out information for old buffer. */
2953 *(yy_c_buf_p) = (yy_hold_char);
2954 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2955 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2956 }
2957
2958 /* Only push if top exists. Otherwise, replace top. */
2959 if (YY_CURRENT_BUFFER)
2960 (yy_buffer_stack_top)++;
2961 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2962
2963 /* copied from yy_switch_to_buffer. */
2964 yy_load_buffer_state( );
2965 (yy_did_buffer_switch_on_eof) = 1;
2966 }
2967
2968 /** Removes and deletes the top of the stack, if present.
2969 * The next element becomes the new top.
2970 *
2971 */
yypop_buffer_state(void)2972 void yypop_buffer_state (void)
2973 {
2974 if (!YY_CURRENT_BUFFER)
2975 return;
2976
2977 yy_delete_buffer(YY_CURRENT_BUFFER );
2978 YY_CURRENT_BUFFER_LVALUE = NULL;
2979 if ((yy_buffer_stack_top) > 0)
2980 --(yy_buffer_stack_top);
2981
2982 if (YY_CURRENT_BUFFER) {
2983 yy_load_buffer_state( );
2984 (yy_did_buffer_switch_on_eof) = 1;
2985 }
2986 }
2987
2988 /* Allocates the stack if it does not exist.
2989 * Guarantees space for at least one push.
2990 */
yyensure_buffer_stack(void)2991 static void yyensure_buffer_stack (void)
2992 {
2993 yy_size_t num_to_alloc;
2994
2995 if (!(yy_buffer_stack)) {
2996
2997 /* First allocation is just for 2 elements, since we don't know if this
2998 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2999 * immediate realloc on the next call.
3000 */
3001 num_to_alloc = 1;
3002 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
3003 (num_to_alloc * sizeof(struct yy_buffer_state*)
3004 );
3005 if ( ! (yy_buffer_stack) )
3006 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3007
3008 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3009
3010 (yy_buffer_stack_max) = num_to_alloc;
3011 (yy_buffer_stack_top) = 0;
3012 return;
3013 }
3014
3015 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3016
3017 /* Increase the buffer to prepare for a possible push. */
3018 int grow_size = 8 /* arbitrary grow size */;
3019
3020 num_to_alloc = (yy_buffer_stack_max) + grow_size;
3021 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
3022 ((yy_buffer_stack),
3023 num_to_alloc * sizeof(struct yy_buffer_state*)
3024 );
3025 if ( ! (yy_buffer_stack) )
3026 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3027
3028 /* zero only the new slots.*/
3029 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3030 (yy_buffer_stack_max) = num_to_alloc;
3031 }
3032 }
3033
3034 /** Setup the input buffer state to scan directly from a user-specified character buffer.
3035 * @param base the character buffer
3036 * @param size the size in bytes of the character buffer
3037 *
3038 * @return the newly allocated buffer state object.
3039 */
yy_scan_buffer(char * base,yy_size_t size)3040 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
3041 {
3042 YY_BUFFER_STATE b;
3043
3044 if ( size < 2 ||
3045 base[size-2] != YY_END_OF_BUFFER_CHAR ||
3046 base[size-1] != YY_END_OF_BUFFER_CHAR )
3047 /* They forgot to leave room for the EOB's. */
3048 return 0;
3049
3050 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
3051 if ( ! b )
3052 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3053
3054 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3055 b->yy_buf_pos = b->yy_ch_buf = base;
3056 b->yy_is_our_buffer = 0;
3057 b->yy_input_file = 0;
3058 b->yy_n_chars = b->yy_buf_size;
3059 b->yy_is_interactive = 0;
3060 b->yy_at_bol = 1;
3061 b->yy_fill_buffer = 0;
3062 b->yy_buffer_status = YY_BUFFER_NEW;
3063
3064 yy_switch_to_buffer(b );
3065
3066 return b;
3067 }
3068
3069 /** Setup the input buffer state to scan a string. The next call to yylex() will
3070 * scan from a @e copy of @a str.
3071 * @param yystr a NUL-terminated string to scan
3072 *
3073 * @return the newly allocated buffer state object.
3074 * @note If you want to scan bytes that may contain NUL values, then use
3075 * yy_scan_bytes() instead.
3076 */
yy_scan_string(yyconst char * yystr)3077 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
3078 {
3079
3080 return yy_scan_bytes(yystr,strlen(yystr) );
3081 }
3082
3083 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
3084 * scan from a @e copy of @a bytes.
3085 * @param yybytes the byte buffer to scan
3086 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
3087 *
3088 * @return the newly allocated buffer state object.
3089 */
yy_scan_bytes(yyconst char * yybytes,yy_size_t _yybytes_len)3090 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
3091 {
3092 YY_BUFFER_STATE b;
3093 char *buf;
3094 yy_size_t n;
3095 yy_size_t i;
3096
3097 /* Get memory for full buffer, including space for trailing EOB's. */
3098 n = _yybytes_len + 2;
3099 buf = (char *) yyalloc(n );
3100 if ( ! buf )
3101 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3102
3103 for ( i = 0; i < _yybytes_len; ++i )
3104 buf[i] = yybytes[i];
3105
3106 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3107
3108 b = yy_scan_buffer(buf,n );
3109 if ( ! b )
3110 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3111
3112 /* It's okay to grow etc. this buffer, and we should throw it
3113 * away when we're done.
3114 */
3115 b->yy_is_our_buffer = 1;
3116
3117 return b;
3118 }
3119
3120 #ifndef YY_EXIT_FAILURE
3121 #define YY_EXIT_FAILURE 2
3122 #endif
3123
yy_fatal_error(yyconst char * msg)3124 static void yy_fatal_error (yyconst char* msg )
3125 {
3126 (void) fprintf( stderr, "%s\n", msg );
3127 exit( YY_EXIT_FAILURE );
3128 }
3129
3130 /* Redefine yyless() so it works in section 3 code. */
3131
3132 #undef yyless
3133 #define yyless(n) \
3134 do \
3135 { \
3136 /* Undo effects of setting up yytext. */ \
3137 int yyless_macro_arg = (n); \
3138 YY_LESS_LINENO(yyless_macro_arg);\
3139 yytext[yyleng] = (yy_hold_char); \
3140 (yy_c_buf_p) = yytext + yyless_macro_arg; \
3141 (yy_hold_char) = *(yy_c_buf_p); \
3142 *(yy_c_buf_p) = '\0'; \
3143 yyleng = yyless_macro_arg; \
3144 } \
3145 while ( 0 )
3146
3147 /* Accessor methods (get/set functions) to struct members. */
3148
3149 /** Get the current line number.
3150 *
3151 */
yyget_lineno(void)3152 int yyget_lineno (void)
3153 {
3154
3155 return yylineno;
3156 }
3157
3158 /** Get the input stream.
3159 *
3160 */
yyget_in(void)3161 FILE *yyget_in (void)
3162 {
3163 return yyin;
3164 }
3165
3166 /** Get the output stream.
3167 *
3168 */
yyget_out(void)3169 FILE *yyget_out (void)
3170 {
3171 return yyout;
3172 }
3173
3174 /** Get the length of the current token.
3175 *
3176 */
yyget_leng(void)3177 yy_size_t yyget_leng (void)
3178 {
3179 return yyleng;
3180 }
3181
3182 /** Get the current token.
3183 *
3184 */
3185
yyget_text(void)3186 char *yyget_text (void)
3187 {
3188 return yytext;
3189 }
3190
3191 /** Set the current line number.
3192 * @param line_number
3193 *
3194 */
yyset_lineno(int line_number)3195 void yyset_lineno (int line_number )
3196 {
3197
3198 yylineno = line_number;
3199 }
3200
3201 /** Set the input stream. This does not discard the current
3202 * input buffer.
3203 * @param in_str A readable stream.
3204 *
3205 * @see yy_switch_to_buffer
3206 */
yyset_in(FILE * in_str)3207 void yyset_in (FILE * in_str )
3208 {
3209 yyin = in_str ;
3210 }
3211
yyset_out(FILE * out_str)3212 void yyset_out (FILE * out_str )
3213 {
3214 yyout = out_str ;
3215 }
3216
yyget_debug(void)3217 int yyget_debug (void)
3218 {
3219 return yy_flex_debug;
3220 }
3221
yyset_debug(int bdebug)3222 void yyset_debug (int bdebug )
3223 {
3224 yy_flex_debug = bdebug ;
3225 }
3226
yy_init_globals(void)3227 static int yy_init_globals (void)
3228 {
3229 /* Initialization is the same as for the non-reentrant scanner.
3230 * This function is called from yylex_destroy(), so don't allocate here.
3231 */
3232
3233 /* We do not touch yylineno unless the option is enabled. */
3234 yylineno = 1;
3235
3236 (yy_buffer_stack) = 0;
3237 (yy_buffer_stack_top) = 0;
3238 (yy_buffer_stack_max) = 0;
3239 (yy_c_buf_p) = (char *) 0;
3240 (yy_init) = 0;
3241 (yy_start) = 0;
3242
3243 /* Defined in main.c */
3244 #ifdef YY_STDINIT
3245 yyin = stdin;
3246 yyout = stdout;
3247 #else
3248 yyin = (FILE *) 0;
3249 yyout = (FILE *) 0;
3250 #endif
3251
3252 /* For future reference: Set errno on error, since we are called by
3253 * yylex_init()
3254 */
3255 return 0;
3256 }
3257
3258 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
yylex_destroy(void)3259 int yylex_destroy (void)
3260 {
3261
3262 /* Pop the buffer stack, destroying each element. */
3263 while(YY_CURRENT_BUFFER){
3264 yy_delete_buffer(YY_CURRENT_BUFFER );
3265 YY_CURRENT_BUFFER_LVALUE = NULL;
3266 yypop_buffer_state();
3267 }
3268
3269 /* Destroy the stack itself. */
3270 yyfree((yy_buffer_stack) );
3271 (yy_buffer_stack) = NULL;
3272
3273 /* Reset the globals. This is important in a non-reentrant scanner so the next time
3274 * yylex() is called, initialization will occur. */
3275 yy_init_globals( );
3276
3277 return 0;
3278 }
3279
3280 /*
3281 * Internal utility routines.
3282 */
3283
3284 #ifndef yytext_ptr
yy_flex_strncpy(char * s1,yyconst char * s2,int n)3285 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3286 {
3287 register int i;
3288 for ( i = 0; i < n; ++i )
3289 s1[i] = s2[i];
3290 }
3291 #endif
3292
3293 #ifdef YY_NEED_STRLEN
yy_flex_strlen(yyconst char * s)3294 static int yy_flex_strlen (yyconst char * s )
3295 {
3296 register int n;
3297 for ( n = 0; s[n]; ++n )
3298 ;
3299
3300 return n;
3301 }
3302 #endif
3303
yyalloc(yy_size_t size)3304 void *yyalloc (yy_size_t size )
3305 {
3306 return (void *) malloc( size );
3307 }
3308
yyrealloc(void * ptr,yy_size_t size)3309 void *yyrealloc (void * ptr, yy_size_t size )
3310 {
3311 /* The cast to (char *) in the following accommodates both
3312 * implementations that use char* generic pointers, and those
3313 * that use void* generic pointers. It works with the latter
3314 * because both ANSI C and C++ allow castless assignment from
3315 * any pointer type to void*, and deal with argument conversions
3316 * as though doing an assignment.
3317 */
3318 return (void *) realloc( (char *) ptr, size );
3319 }
3320
yyfree(void * ptr)3321 void yyfree (void * ptr )
3322 {
3323 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
3324 }
3325
3326 #define YYTABLES_NAME "yytables"
3327
3328 #line 324 "pl-lexer.l"
3329
3330
3331
3332 /* added by Thomas Esser, suggested by Olaf Weber */
3333 #ifdef yywrap
3334 #undef yywrap
3335 #endif
3336
3337 int
yywrap(void)3338 yywrap (void)
3339 { return 1; }
3340
3341 static void
scan_int(unsigned base)3342 scan_int(unsigned base)
3343 {
3344 register unsigned j, q = 0x10000 / base, c0=0, c1=0, i=1;
3345
3346 if ((base<BASE_MIN) || (base>BASE_MAX))
3347 internal_error_1("scan_int (base=%d)", base);
3348 while ((yytext[i]==' ') || (yytext[i]=='\t')) {
3349 yytext[i] = ' ';
3350 i++;
3351 }
3352 for (; i<yyleng; i++) {
3353 j = yytext[i];
3354 if (j>='A') j = j + '0' + 10 - 'A' ;
3355 c0 = base*c0 + (c1 / q);
3356 c1 = base*(c1 % q) + j - '0';
3357 if (c0 > 0xffff) {
3358 lex_error_s("numeric value (%s) too large; set to 0", yytext);
3359 c0=0; c1=0; break;
3360 }
3361 }
3362 yylval.yint = c0 * 0x10000 + c1;
3363 }
3364
3365 static void
scan_fix(void)3366 scan_fix(void)
3367 {
3368 unsigned i=1;
3369 unsigned sign = 1;
3370 unsigned j=0;
3371 unsigned acc=0;
3372 unsigned int_part;
3373 unsigned fraction_digits[7];
3374
3375 while ((yytext[i]==' ') || (yytext[i]=='\t') ||
3376 (yytext[i]=='+') || (yytext[i]=='-')) {
3377 if (yytext[i]=='\t') yytext[i] = ' ';
3378 if (yytext[i]=='-') sign *= -1;
3379 i++;
3380 }
3381 acc=0;
3382 while ((i<yyleng) && (yytext[i]!='.')) {
3383 acc = acc*10 + yytext[i]-'0';
3384 i++;
3385 if (acc >=0x800 ) {
3386 lex_error_s("fix value (%s) too large; set to 0", yytext);
3387 yylval.yfix = 0;
3388 return;
3389 }
3390 }
3391 int_part = acc; acc = 0;
3392 if (i < yyleng) {
3393 i++;
3394 while ((i<yyleng) && j<7) {
3395 fraction_digits[j] = 0x200000*(yytext[i]-'0');
3396 i++; j++;
3397 }
3398 while (j>0) {acc = fraction_digits[--j] + acc / 10;}
3399 acc = (acc + 10) / 20;
3400 }
3401 if ((acc > UNITY) && (int_part=2047)) {
3402 lex_error_s("fix value (%s) too large; set to 0", yytext);
3403 yylval.yfix = 0;
3404 return;
3405 }
3406 yylval.yfix = sign * (int_part*UNITY + acc);
3407 }
3408
3409 static void
scan_char(void)3410 scan_char(void)
3411 {
3412 register unsigned i=1;
3413
3414 while ((yytext[i]==' ') || (yytext[i]=='\t')) i++;
3415 if ((yytext[i]<041) || (yytext[i]>0176) ||
3416 (yytext[i]=='(') || (yytext[i]==')')) {
3417 lex_error_1("C value (H %X) must be ASCII (not paren); "
3418 "set to 'A'", yytext[i]);
3419 yylval.yint = 'A';
3420 } else yylval.yint = yytext[i];
3421 }
3422
3423 static void
scan_string(const char * attribute,unsigned keep,unsigned length)3424 scan_string(const char *attribute, unsigned keep, unsigned length)
3425 {
3426 register unsigned c, saved_ptr = 0, paren_level = 0;
3427 unsigned error_msg = FALSE;
3428
3429 if ((keep<KEEP_MIN) || (keep>KEEP_MAX))
3430 internal_error_1("scan_string (keep=%d)", keep);
3431 while (((c = input()) != EOF) &&
3432 ((c == ' ') || (c == '\t') || (c == '\n'))) {
3433 if (c == '\n') {line_number++;}
3434 }
3435 if (c==EOF) fatal_error_s("EOF while scanning %s", attribute);
3436 while ((c != EOF) &&
3437 ((c != ')') || (paren_level>0))) {
3438 if (c==')') {
3439 paren_level--;
3440 if (keep==KEEP_CONVERT) {
3441 lex_error_s_1("%s character (H %X) converted to slash",
3442 attribute, c);
3443 c = '/';
3444 }
3445 } else if (c=='(') {
3446 paren_level++;
3447 if (keep==KEEP_CONVERT) {
3448 lex_error_s_1("%s character (H %X) converted to slash",
3449 attribute, c);
3450 c = '/';
3451 }
3452 } else if ((c<' ') || (c>='~')) {
3453 if (c=='\n') line_number++;
3454 if (keep==KEEP_CONVERT) {
3455 lex_error_s_1("%s character (H %X) converted to blank",
3456 attribute, c);
3457 c = ' ';
3458 }
3459 }
3460 if (saved_ptr<(MAX_PTR-3))
3461 saved_text[saved_ptr++] = c;
3462 else if (error_msg == FALSE) {
3463 lex_error_s_1("%s string longer than %d characters; truncating",
3464 attribute, MAX_PTR);
3465 error_msg = TRUE;
3466 }
3467 c = input();
3468 }
3469 if (c==EOF) fatal_error_s("EOF while scanning %s", attribute);
3470 unput(')');
3471 saved_text[saved_ptr++] = '\0';
3472 if (keep!=KEEP_NONE) {
3473 if ((length != 0) && (strlen(saved_text)>length)) {
3474 lex_error_s_1("%s string limited to %d characters; truncated",
3475 attribute, length);
3476 saved_text[length] = '\0';
3477 }
3478 yylval.ystring = xstrdup(saved_text);
3479 } else {
3480 yylval.ystring = NULL;
3481 }
3482 }
3483
3484 static void
scan_hex_string(void)3485 scan_hex_string(void)
3486 {
3487 register unsigned c, saved_ptr = 0;
3488 unsigned error_msg = FALSE;
3489
3490 while ((c = input()) != EOF) {
3491 if (((c >= '0') && (c <= '9')) || ((c >= 'A') && (c <= 'F'))) {
3492 if (saved_ptr<(MAX_PTR-3))
3493 saved_text[saved_ptr++] = c;
3494 else if (error_msg == FALSE) {
3495 lex_error_1("SPECIALHEX string longer than %d characters; truncating",
3496 MAX_PTR);
3497 error_msg = TRUE;
3498 }
3499 } else if (c == '\n') {
3500 line_number++;
3501 } else if ((c != ' ') && (c != '\t')) {
3502 unput(c);
3503 break;
3504 }
3505 }
3506 if (c == EOF) fatal_error_0("EOF while scanning SPECIALHEX");
3507 saved_text[saved_ptr++] = '\0';
3508 yylval.ystring = xstrdup(saved_text);
3509 }
3510
3511