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