Fix wrong register operands in x86-64 instruction decoding
[dyninst.git] / dynC_API / src / lex.dynC.C
1 #line 2 "lex.dynC.C"
2
3 #line 4 "lex.dynC.C"
4
5 #define  YY_INT_ALIGNED short int
6
7 /* A lexical scanner generated by flex */
8
9 #define yy_create_buffer dynC_create_buffer
10 #define yy_delete_buffer dynC_delete_buffer
11 #define yy_flex_debug dynC_flex_debug
12 #define yy_init_buffer dynC_init_buffer
13 #define yy_flush_buffer dynC_flush_buffer
14 #define yy_load_buffer_state dynC_load_buffer_state
15 #define yy_switch_to_buffer dynC_switch_to_buffer
16 #define yyin dynCin
17 #define yyleng dynCleng
18 #define yylex dynClex
19 #define yylineno dynClineno
20 #define yyout dynCout
21 #define yyrestart dynCrestart
22 #define yytext dynCtext
23 #define yywrap dynCwrap
24 #define yyalloc dynCalloc
25 #define yyrealloc dynCrealloc
26 #define yyfree dynCfree
27
28 #define FLEX_SCANNER
29 #define YY_FLEX_MAJOR_VERSION 2
30 #define YY_FLEX_MINOR_VERSION 6
31 #define YY_FLEX_SUBMINOR_VERSION 1
32 #if YY_FLEX_SUBMINOR_VERSION > 0
33 #define FLEX_BETA
34 #endif
35
36 /* First, we deal with  platform-specific or compiler-specific issues. */
37
38 /* begin standard C headers. */
39 #include <stdio.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <stdlib.h>
43
44 /* end standard C headers. */
45
46 /* flex integer type definitions */
47
48 #ifndef FLEXINT_H
49 #define FLEXINT_H
50
51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52
53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54
55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56  * if you want the limit (max/min) macros for int types. 
57  */
58 #ifndef __STDC_LIMIT_MACROS
59 #define __STDC_LIMIT_MACROS 1
60 #endif
61
62 #include <inttypes.h>
63 typedef int8_t flex_int8_t;
64 typedef uint8_t flex_uint8_t;
65 typedef int16_t flex_int16_t;
66 typedef uint16_t flex_uint16_t;
67 typedef int32_t flex_int32_t;
68 typedef uint32_t flex_uint32_t;
69 #else
70 typedef signed char flex_int8_t;
71 typedef short int flex_int16_t;
72 typedef int flex_int32_t;
73 typedef unsigned char flex_uint8_t; 
74 typedef unsigned short int flex_uint16_t;
75 typedef unsigned int flex_uint32_t;
76
77 /* Limits of integral types. */
78 #ifndef INT8_MIN
79 #define INT8_MIN               (-128)
80 #endif
81 #ifndef INT16_MIN
82 #define INT16_MIN              (-32767-1)
83 #endif
84 #ifndef INT32_MIN
85 #define INT32_MIN              (-2147483647-1)
86 #endif
87 #ifndef INT8_MAX
88 #define INT8_MAX               (127)
89 #endif
90 #ifndef INT16_MAX
91 #define INT16_MAX              (32767)
92 #endif
93 #ifndef INT32_MAX
94 #define INT32_MAX              (2147483647)
95 #endif
96 #ifndef UINT8_MAX
97 #define UINT8_MAX              (255U)
98 #endif
99 #ifndef UINT16_MAX
100 #define UINT16_MAX             (65535U)
101 #endif
102 #ifndef UINT32_MAX
103 #define UINT32_MAX             (4294967295U)
104 #endif
105
106 #endif /* ! C99 */
107
108 #endif /* ! FLEXINT_H */
109
110 /* TODO: this is always defined, so inline it */
111 #define yyconst const
112
113 #if defined(__GNUC__) && __GNUC__ >= 3
114 #define yynoreturn __attribute__((__noreturn__))
115 #else
116 #define yynoreturn
117 #endif
118
119 /* Returned upon end-of-file. */
120 #define YY_NULL 0
121
122 /* Promotes a possibly negative, possibly signed char to an unsigned
123  * integer for use as an array index.  If the signed char is negative,
124  * we want to instead treat it as an 8-bit unsigned char, hence the
125  * double cast.
126  */
127 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
128
129 /* Enter a start condition.  This macro really ought to take a parameter,
130  * but we do it the disgusting crufty way forced on us by the ()-less
131  * definition of BEGIN.
132  */
133 #define BEGIN (yy_start) = 1 + 2 *
134
135 /* Translate the current start state into a value that can be later handed
136  * to BEGIN to return to the state.  The YYSTATE alias is for lex
137  * compatibility.
138  */
139 #define YY_START (((yy_start) - 1) / 2)
140 #define YYSTATE YY_START
141
142 /* Action number for EOF rule of a given start state. */
143 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
144
145 /* Special action meaning "start processing a new file". */
146 #define YY_NEW_FILE dynCrestart(dynCin  )
147
148 #define YY_END_OF_BUFFER_CHAR 0
149
150 /* Size of default input buffer. */
151 #ifndef YY_BUF_SIZE
152 #ifdef __ia64__
153 /* On IA-64, the buffer size is 16k, not 8k.
154  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
155  * Ditto for the __ia64__ case accordingly.
156  */
157 #define YY_BUF_SIZE 32768
158 #else
159 #define YY_BUF_SIZE 16384
160 #endif /* __ia64__ */
161 #endif
162
163 /* The state buf must be large enough to hold one state per character in the main buffer.
164  */
165 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
166
167 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
168 #define YY_TYPEDEF_YY_BUFFER_STATE
169 typedef struct yy_buffer_state *YY_BUFFER_STATE;
170 #endif
171
172 #ifndef YY_TYPEDEF_YY_SIZE_T
173 #define YY_TYPEDEF_YY_SIZE_T
174 typedef size_t yy_size_t;
175 #endif
176
177 extern int dynCleng;
178
179 extern FILE *dynCin, *dynCout;
180
181 #define EOB_ACT_CONTINUE_SCAN 0
182 #define EOB_ACT_END_OF_FILE 1
183 #define EOB_ACT_LAST_MATCH 2
184
185     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
186      *       access to the local variable yy_act. Since yyless() is a macro, it would break
187      *       existing scanners that call yyless() from OUTSIDE dynClex. 
188      *       One obvious solution it to make yy_act a global. I tried that, and saw
189      *       a 5% performance hit in a non-dynClineno scanner, because yy_act is
190      *       normally declared as a register variable-- so it is not worth it.
191      */
192     #define  YY_LESS_LINENO(n) \
193             do { \
194                 int yyl;\
195                 for ( yyl = n; yyl < dynCleng; ++yyl )\
196                     if ( dynCtext[yyl] == '\n' )\
197                         --dynClineno;\
198             }while(0)
199     #define YY_LINENO_REWIND_TO(dst) \
200             do {\
201                 const char *p;\
202                 for ( p = yy_cp-1; p >= (dst); --p)\
203                     if ( *p == '\n' )\
204                         --dynClineno;\
205             }while(0)
206     
207 /* Return all but the first "n" matched characters back to the input stream. */
208 #define yyless(n) \
209         do \
210                 { \
211                 /* Undo effects of setting up dynCtext. */ \
212         int yyless_macro_arg = (n); \
213         YY_LESS_LINENO(yyless_macro_arg);\
214                 *yy_cp = (yy_hold_char); \
215                 YY_RESTORE_YY_MORE_OFFSET \
216                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
217                 YY_DO_BEFORE_ACTION; /* set up dynCtext again */ \
218                 } \
219         while ( 0 )
220
221 #define unput(c) yyunput( c, (yytext_ptr)  )
222
223 #ifndef YY_STRUCT_YY_BUFFER_STATE
224 #define YY_STRUCT_YY_BUFFER_STATE
225 struct yy_buffer_state
226         {
227         FILE *yy_input_file;
228
229         char *yy_ch_buf;                /* input buffer */
230         char *yy_buf_pos;               /* current position in input buffer */
231
232         /* Size of input buffer in bytes, not including room for EOB
233          * characters.
234          */
235         int yy_buf_size;
236
237         /* Number of characters read into yy_ch_buf, not including EOB
238          * characters.
239          */
240         int yy_n_chars;
241
242         /* Whether we "own" the buffer - i.e., we know we created it,
243          * and can realloc() it to grow it, and should free() it to
244          * delete it.
245          */
246         int yy_is_our_buffer;
247
248         /* Whether this is an "interactive" input source; if so, and
249          * if we're using stdio for input, then we want to use getc()
250          * instead of fread(), to make sure we stop fetching input after
251          * each newline.
252          */
253         int yy_is_interactive;
254
255         /* Whether we're considered to be at the beginning of a line.
256          * If so, '^' rules will be active on the next match, otherwise
257          * not.
258          */
259         int yy_at_bol;
260
261     int yy_bs_lineno; /**< The line count. */
262     int yy_bs_column; /**< The column count. */
263     
264         /* Whether to try to fill the input buffer when we reach the
265          * end of it.
266          */
267         int yy_fill_buffer;
268
269         int yy_buffer_status;
270
271 #define YY_BUFFER_NEW 0
272 #define YY_BUFFER_NORMAL 1
273         /* When an EOF's been seen but there's still some text to process
274          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
275          * shouldn't try reading from the input source any more.  We might
276          * still have a bunch of tokens to match, though, because of
277          * possible backing-up.
278          *
279          * When we actually see the EOF, we change the status to "new"
280          * (via dynCrestart()), so that the user can continue scanning by
281          * just pointing dynCin at a new input file.
282          */
283 #define YY_BUFFER_EOF_PENDING 2
284
285         };
286 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
287
288 /* Stack of input buffers. */
289 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
290 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
291 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
292
293 /* We provide macros for accessing buffer states in case in the
294  * future we want to put the buffer states in a more general
295  * "scanner state".
296  *
297  * Returns the top of the stack, or NULL.
298  */
299 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
300                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
301                           : NULL)
302
303 /* Same as previous macro, but useful when we know that the buffer stack is not
304  * NULL or when we need an lvalue. For internal use only.
305  */
306 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
307
308 /* yy_hold_char holds the character lost when dynCtext is formed. */
309 static char yy_hold_char;
310 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
311 int dynCleng;
312
313 /* Points to current character in buffer. */
314 static char *yy_c_buf_p = NULL;
315 static int yy_init = 0;         /* whether we need to initialize */
316 static int yy_start = 0;        /* start state number */
317
318 /* Flag which is used to allow dynCwrap()'s to do buffer switches
319  * instead of setting up a fresh dynCin.  A bit of a hack ...
320  */
321 static int yy_did_buffer_switch_on_eof;
322
323 void dynCrestart (FILE *input_file  );
324 void dynC_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
325 YY_BUFFER_STATE dynC_create_buffer (FILE *file,int size  );
326 void dynC_delete_buffer (YY_BUFFER_STATE b  );
327 void dynC_flush_buffer (YY_BUFFER_STATE b  );
328 void dynCpush_buffer_state (YY_BUFFER_STATE new_buffer  );
329 void dynCpop_buffer_state (void );
330
331 static void dynCensure_buffer_stack (void );
332 static void dynC_load_buffer_state (void );
333 static void dynC_init_buffer (YY_BUFFER_STATE b,FILE *file  );
334
335 #define YY_FLUSH_BUFFER dynC_flush_buffer(YY_CURRENT_BUFFER )
336
337 YY_BUFFER_STATE dynC_scan_buffer (char *base,yy_size_t size  );
338 YY_BUFFER_STATE dynC_scan_string (yyconst char *yy_str  );
339 YY_BUFFER_STATE dynC_scan_bytes (yyconst char *bytes,int len  );
340
341 void *dynCalloc (yy_size_t  );
342 void *dynCrealloc (void *,yy_size_t  );
343 void dynCfree (void *  );
344
345 #define yy_new_buffer dynC_create_buffer
346
347 #define yy_set_interactive(is_interactive) \
348         { \
349         if ( ! YY_CURRENT_BUFFER ){ \
350         dynCensure_buffer_stack (); \
351                 YY_CURRENT_BUFFER_LVALUE =    \
352             dynC_create_buffer(dynCin,YY_BUF_SIZE ); \
353         } \
354         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
355         }
356
357 #define yy_set_bol(at_bol) \
358         { \
359         if ( ! YY_CURRENT_BUFFER ){\
360         dynCensure_buffer_stack (); \
361                 YY_CURRENT_BUFFER_LVALUE =    \
362             dynC_create_buffer(dynCin,YY_BUF_SIZE ); \
363         } \
364         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
365         }
366
367 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
368
369 /* Begin user sect3 */
370
371 #define dynCwrap() (/*CONSTCOND*/1)
372 #define YY_SKIP_YYWRAP
373
374 typedef unsigned char YY_CHAR;
375
376 FILE *dynCin = NULL, *dynCout = NULL;
377
378 typedef int yy_state_type;
379
380 extern int dynClineno;
381
382 int dynClineno = 1;
383
384 extern char *dynCtext;
385 #ifdef yytext_ptr
386 #undef yytext_ptr
387 #endif
388 #define yytext_ptr dynCtext
389
390 static yy_state_type yy_get_previous_state (void );
391 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
392 static int yy_get_next_buffer (void );
393 static void yynoreturn yy_fatal_error (yyconst char* msg  );
394
395 /* Done after the current pattern has been matched and before the
396  * corresponding action - sets up dynCtext.
397  */
398 #define YY_DO_BEFORE_ACTION \
399         (yytext_ptr) = yy_bp; \
400         dynCleng = (int) (yy_cp - yy_bp); \
401         (yy_hold_char) = *yy_cp; \
402         *yy_cp = '\0'; \
403         (yy_c_buf_p) = yy_cp;
404
405 #define YY_NUM_RULES 107
406 #define YY_END_OF_BUFFER 108
407 /* This struct is not used in this scanner,
408    but its presence is necessary. */
409 struct yy_trans_info
410         {
411         flex_int32_t yy_verify;
412         flex_int32_t yy_nxt;
413         };
414 static yyconst flex_int16_t yy_accept[481] =
415     {   0,
416         0,    0,    1,    1,    0,    0,  108,  106,  103,  105,
417        90,   42,   96,   89,  106,   84,   85,   94,   93,   81,
418        92,   88,   95,   34,   34,   82,   76,   97,   83,   98,
419       101,   33,   33,   33,   86,   87,   99,  102,   33,   33,
420        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
421        33,   33,   77,  100,   78,   91,  106,  103,   90,   42,
422        96,   89,  106,   84,   85,   94,   93,   81,   92,   88,
423        95,   34,   34,   82,   97,   83,   98,  101,   33,   33,
424        33,   86,   87,   99,  102,   33,   33,   33,   33,   33,
425        33,   33,   33,   33,   33,   33,   33,   33,   33,  100,
426
427        91,    1,    3,    2,   53,   44,   43,  107,   75,   61,
428        78,   80,   70,   62,    0,    0,   59,   67,   57,   68,
429        34,   58,   69,    0,   40,    6,    5,   60,   41,   34,
430         0,   37,    0,   34,   77,   66,   72,   74,   73,   65,
431        33,    0,   33,   63,   33,   33,   33,   33,   33,   33,
432        33,   33,   33,   33,   33,   33,   33,   16,   33,   33,
433        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
434        79,   64,   71,    0,  104,   75,   61,   78,   70,   62,
435         0,  104,    0,   59,   67,   57,   68,   34,   58,   69,
436         0,   40,    6,    5,   60,   41,   34,    0,   37,    0,
437
438        34,   77,   66,   72,   74,   73,   65,   33,    0,   33,
439        63,   33,   33,   33,   33,   33,   33,   33,   33,   33,
440        33,   33,   33,   33,   16,   33,   33,   33,   33,   33,
441        33,   33,   33,   33,   33,   33,   33,   64,   71,    1,
442         2,    2,    4,   53,   52,   45,   46,   50,   51,   47,
443        49,   48,   38,   54,    0,   40,    5,   40,    0,   41,
444        36,    0,   39,   35,   56,   55,   33,   33,   33,   33,
445        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
446        33,    7,   33,   33,   33,   31,   33,   33,   33,   33,
447        33,   33,   33,   33,   33,   33,   38,   54,    0,   40,
448
449         5,   40,    0,   41,   36,    0,   39,   35,   56,   55,
450        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
451        33,   33,   33,   33,   33,    7,   33,   33,   33,   31,
452        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
453        45,   46,    0,   40,    0,   40,    0,   41,   39,   35,
454        32,   12,    7,   33,   33,   33,   33,   15,   11,   33,
455        33,   29,   33,   28,   33,   33,   33,   33,   33,   33,
456        33,   33,   22,   33,   33,    0,   40,    0,   40,    0,
457        41,   39,   35,   32,   12,    7,   33,   33,   33,   33,
458        15,   11,   33,   33,   29,   33,   28,   33,   33,   33,
459
460        33,   33,   33,   33,   33,   22,   33,   33,   45,    0,
461        40,    0,    8,   13,   33,   33,   33,   23,   33,   33,
462        24,   25,   33,   33,   33,   33,   33,   33,   10,    0,
463        40,    0,    8,   13,   33,   33,   33,   23,   33,   33,
464        24,   25,   33,   33,   33,   33,   33,   33,   10,   33,
465        33,   33,   26,   17,   18,   19,    9,   20,   33,   33,
466        33,   33,   26,   17,   18,   19,    9,   20,   33,   14,
467        27,   33,   21,   14,   27,   33,   21,   30,   30,    0
468     } ;
469
470 static yyconst YY_CHAR yy_ec[256] =
471     {   0,
472         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
473         2,    2,    1,    1,    1,    1,    1,    1,    1,    1,
474         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
475         1,    2,    4,    5,    1,    1,    6,    7,    8,    9,
476        10,   11,   12,   13,   14,   15,   16,   17,   18,   18,
477        18,   18,   18,   18,   18,   19,   19,   20,   21,   22,
478        23,   24,   25,    1,   26,   26,   26,   26,   27,   28,
479        29,   29,   29,   29,   29,   30,   29,   31,   29,   29,
480        29,   29,   29,   29,   32,   29,   29,   33,   29,   29,
481        34,   35,   36,   37,   38,   39,   40,   41,   42,   43,
482
483        44,   45,   46,   47,   48,   29,   29,   49,   50,   51,
484        52,   53,   29,   54,   55,   56,   57,   58,   59,   33,
485        60,   61,   62,   63,   64,   65,    1,    1,    1,    1,
486         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
487         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
488         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
489         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
490         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
491         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
492         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
493
494         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
495         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
496         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
497         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
498         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
499         1,    1,    1,    1,    1
500     } ;
501
502 static yyconst YY_CHAR yy_meta[66] =
503     {   0,
504         1,    1,    2,    1,    3,    1,    1,    4,    1,    1,
505         5,    1,    1,    1,    1,    1,    6,    6,    6,    1,
506         7,    1,    1,    1,    1,    6,    6,    6,    8,    8,
507         8,    8,    8,    1,    3,    1,    1,    8,    1,    6,
508         6,    6,    6,    6,    6,    8,    8,    8,    8,    8,
509         8,    8,    8,    8,    8,    8,    8,    8,    8,    8,
510         8,    7,    1,    7,    1
511     } ;
512
513 static yyconst flex_uint16_t yy_base[494] =
514     {   0,
515         0,   65,  128,  129,  130,  131, 1038, 1039, 1039, 1039,
516      1014, 1039,  114,  134, 1001, 1039, 1039, 1012,  130, 1039,
517       131,  141,  151,  164,  151, 1039, 1039,  141, 1011,  120,
518      1039,    0, 1025, 1000, 1039, 1039, 1008, 1039,  978,  133,
519       143,  126,  149,  980,  101,  976,  987,  982,  145,  145,
520       974,  972, 1017,  148, 1039, 1039, 1019, 1018,  187, 1017,
521       199,  209,  206, 1016, 1015,  197,  212, 1014,  225,  235,
522       214,  268,  323, 1013,  223,  228,  233, 1012,  380, 1006,
523       981, 1009, 1008,  237, 1007,  957,  215,  214,  137,  224,
524       959,  214,  955,  966,  961,  232,  215,  953,  951,  269,
525
526       999,    0, 1039,  266,    0, 1039, 1039,  292, 1039, 1039,
527      1039, 1039, 1039, 1039,  199,  281, 1039, 1039, 1039, 1039,
528       285, 1039, 1039,  986,  317, 1039,    0, 1039,  429,  264,
529       310,  319,    0,    0, 1039,  977, 1039, 1039, 1039,  976,
530         0,  963,  967, 1039,  944,  940,  954,  942,  947,  934,
531       939,  934,  931,  938,  934,  934,  932,    0,  163,  248,
532       929,  105,  930,  920,  193,  932,  922,  925,  929,  928,
533      1039, 1039, 1039,  972, 1039,  971,  970,  969,  968,  967,
534       441,  270,  447,  966,  965,  964,  963,  356,  962,  961,
535       303,  509,  960,  451,  959,  556,  603,  452,  449,  658,
536
537       701,  958,  316,  957,  956,  955,  354,    0,  479,  927,
538       953,  903,  899,  913,  901,  906,  893,  898,  893,  890,
539       897,  893,  893,  877,    0,  252,  272,  860,  274,  861,
540       844,  316,  852,  840,  833,  830,  824,  848,  847,    0,
541       347,  349, 1039,    0, 1039,  466,  471, 1039, 1039, 1039,
542      1039, 1039, 1039, 1039,  504, 1039,    0,  533,  528, 1039,
543       322,  474,  562,  445, 1039, 1039,  819,  798,  802,  791,
544       789,  803,  801,  793,  796,  789,  783,  797,  794,  794,
545       776,    0,  789,  782,  787,    0,  769,  771,  780,  767,
546       762,  762,  773,  772,  762,  769,  808,  807,  552,  806,
547
548       527,  756,  585,  805,  582,  514,  606,  583,  804,  796,
549       768,  743,  747,  736,  734,  748,  746,  737,  738,  731,
550       722,  732,  728,  728,  712,    0,  724,  717,  717,    0,
551       699,  701,  704,  691,  687,  687,  695,  694,  684,  687,
552       478,  576,  609,  661,  631, 1039,  639,  664, 1039,  614,
553         0,    0,  367,  673,  670,  675,  666,    0,    0,  671,
554       658,  656,  671,    0,  659,  655,  643,  640,  643,  645,
555       648,  646,    0,  644,  619,  650,  704,  723,  659,  743,
556       748,  656,  722,    0,    0,  440,  598,  585,  592,  587,
557         0,    0,  593,  573,  563,  577,    0,  567,  560,  554,
558
559       542,  544,  539,  534,  530,    0,  525,  516,  647,  655,
560       785,  456, 1039,    0,  513,  505,  489,    0,  490,  486,
561         0,    0,  483,  484,  483,  468,  473,  475,    0,  777,
562       803,  554,  507,    0,  459,  463,  449,    0,  453,  450,
563         0,    0,  435,  435,  423,  407,  414,  416,    0,  397,
564       345,  312,    0,    0,    0,    0,    0,    0,  286,  260,
565       259,  241,    0,    0,    0,    0,    0,    0,  231,    0,
566         0,  210,    0,    0,    0,  125,    0,    0,    0, 1039,
567       852,  860,  868,  871,  879,  887,  895,  903,  911,  919,
568       927,  166,  935
569
570     } ;
571
572 static yyconst flex_int16_t yy_def[494] =
573     {   0,
574       480,  480,  481,  481,  482,  482,  480,  480,  480,  480,
575       480,  480,  480,  480,  483,  480,  480,  480,  480,  480,
576       480,  480,  480,  480,   24,  480,  480,  480,  480,  480,
577       480,  484,  484,  484,  480,  480,  480,  480,  484,  484,
578       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
579       484,  484,  480,  480,  480,  480,  485,  485,  485,  485,
580       485,  485,  486,  485,  485,  485,  485,  485,  485,  485,
581       485,  485,  485,  485,  485,  485,  485,  485,  480,   79,
582        79,  485,  485,  485,  485,   79,   79,   79,   79,   79,
583        79,   79,   79,   79,   79,   79,   79,   79,   79,  485,
584
585       485,  487,  480,  488,  489,  480,  480,  490,  480,  480,
586       480,  480,  480,  480,  483,  483,  480,  480,  480,  480,
587       480,  480,  480,  480,  480,  480,  491,  480,  480,   24,
588       480,  480,  492,   25,  480,  480,  480,  480,  480,  480,
589       484,  483,  484,  480,  484,  484,  484,  484,  484,  484,
590       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
591       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
592       480,  480,  480,  485,  480,  485,  485,  485,  485,  485,
593       486,  483,  486,  485,  485,  485,  485,  485,  485,  485,
594       485,  485,  485,  493,  485,  485,  485,  485,  485,  485,
595
596       485,  485,  485,  485,  485,  485,  485,   79,  486,   79,
597       485,   79,   79,   79,   79,   79,   79,   79,   79,   79,
598        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
599        79,   79,   79,   79,   79,   79,   79,  485,  485,  487,
600       488,  488,  480,  489,  480,  480,  480,  480,  480,  480,
601       480,  480,  480,  480,  480,  480,  491,  480,  480,  480,
602       480,  480,  480,  492,  480,  480,  484,  484,  484,  484,
603       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
604       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
605       484,  484,  484,  484,  484,  484,  485,  485,  485,  485,
606
607       493,  485,  485,  485,  485,  485,  485,  200,  485,  485,
608        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
609        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
610        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
611       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
612       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
613       484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
614       484,  484,  484,  484,  484,  485,  485,  485,  485,  485,
615       485,  485,  485,   79,   79,   79,   79,   79,   79,   79,
616        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
617
618        79,   79,   79,   79,   79,   79,   79,   79,  480,  480,
619       480,  480,  480,  484,  484,  484,  484,  484,  484,  484,
620       484,  484,  484,  484,  484,  484,  484,  484,  484,  485,
621       485,  485,  485,   79,   79,   79,   79,   79,   79,   79,
622        79,   79,   79,   79,   79,   79,   79,   79,   79,  484,
623       484,  484,  484,  484,  484,  484,  484,  484,  484,   79,
624        79,   79,   79,   79,   79,   79,   79,   79,   79,  484,
625       484,  484,  484,   79,   79,   79,   79,  484,   79,    0,
626       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
627       480,  480,  480
628
629     } ;
630
631 static yyconst flex_uint16_t yy_nxt[1105] =
632     {   0,
633         8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
634        18,   19,   20,   21,   22,   23,   24,   25,   25,   26,
635        27,   28,   29,   30,   31,   32,   32,   32,   32,   33,
636        34,   32,   32,   35,    8,   36,   37,    8,   38,   32,
637        39,   40,   41,   42,   43,   44,   32,   45,   46,   32,
638        32,   32,   47,   48,   49,   50,   51,   52,   32,   32,
639        32,   53,   54,   55,   56,   57,   58,   10,   59,   60,
640        61,   62,   63,   64,   65,   66,   67,   68,   69,   70,
641        71,   72,   73,   73,   74,   27,   75,   76,   77,   78,
642        79,   79,   79,   79,   80,   81,   79,   79,   82,   57,
643
644        83,   84,   57,   85,   79,   86,   87,   88,   89,   90,
645        91,   79,   92,   93,   79,   79,   79,   94,   95,   96,
646        97,   98,   99,   79,   79,   79,   53,  100,   55,  101,
647       103,  103,  106,  106,  107,  107,  110,  111,  104,  104,
648       113,  118,  139,  140,  120,  158,  135,  121,  121,  121,
649       286,  159,  119,  122,  123,  124,  114,  125,  125,  125,
650       287,  126,  136,  137,  108,  108,  127,  134,  134,  134,
651       172,  264,  146,  128,  152,  479,  153,  112,  129,  147,
652       130,  130,  130,  480,  148,  219,  149,  220,  154,  175,
653       131,  163,  164,  132,  150,  132,  133,  155,  167,  175,
654
655       165,  175,  151,  166,  168,  156,  253,  131,  182,  176,
656       173,  175,  132,  174,  175,  179,  175,  281,  282,  184,
657       132,  177,  178,  185,  193,  175,  115,  175,  202,  194,
658       175,  180,  290,  116,  186,  175,  195,  175,  187,  175,
659       183,  188,  188,  188,  203,  204,  291,  189,  190,  191,
660       205,  192,  192,  192,  213,  206,  207,  216,  225,  211,
661       478,  214,  112,  221,  226,  217,  215,  115,  234,  115,
662       175,  175,  222,  218,  235,  477,  242,  253,  230,  231,
663       223,  243,  196,  480,  197,  197,  197,  232,  115,  283,
664       233,  238,  476,  261,  198,  261,  480,  199,  284,  199,
665
666       200,  121,  121,  121,  116,  175,  325,  326,  246,  246,
667       247,  198,  261,  327,  475,  474,  199,  298,  175,  330,
668       261,  262,  328,  262,  199,  175,  263,  263,  263,  331,
669       473,  239,  248,  125,  125,  125,  249,  196,  309,  201,
670       201,  201,  250,  255,  256,  251,  256,  252,  132,  198,
671       132,  261,  199,  261,  199,  334,  175,  480,  175,  242,
672       255,  256,  480,  472,  243,  256,  198,  132,  412,  335,
673       261,  199,  188,  188,  188,  132,  310,  413,  261,  199,
674       174,  174,  175,  174,  174,  174,  174,  174,  174,  174,
675       174,  174,  174,  174,  174,  174,  208,  208,  208,  174,
676
677       471,  174,  174,  174,  174,  208,  208,  208,  208,  208,
678       208,  208,  208,  174,  174,  174,  174,  208,  174,  208,
679       208,  208,  208,  208,  208,  208,  208,  208,  208,  208,
680       208,  208,  208,  208,  208,  208,  208,  208,  208,  208,
681       208,  432,  174,  182,  174,  258,  258,  258,  297,  175,
682       433,  175,  470,  175,  175,  259,  260,  412,  260,  469,
683       468,  115,  467,  306,  466,  306,  413,  115,  307,  307,
684       307,  257,  259,  260,  350,  183,  350,  260,  199,  465,
685       199,  182,  341,  341,  342,  464,  174,  342,  342,  342,
686       263,  263,  263,  350,  409,  409,  342,  199,  463,  115,
687
688       462,  350,  115,  461,  115,  199,  326,  460,  115,  175,
689       115,  175,  257,  183,  257,  343,  175,  343,  459,  458,
690       344,  344,  344,  457,  456,  192,  192,  192,  455,  175,
691       307,  307,  307,  454,  453,  299,  300,  452,  300,  347,
692       115,  347,  115,  451,  348,  348,  348,  257,  282,  258,
693       258,  258,  299,  300,  175,  432,  175,  300,  175,  345,
694       346,  450,  346,  376,  433,  376,  449,  448,  377,  377,
695       377,  447,  302,  302,  302,  446,  345,  346,  263,  263,
696       263,  346,  303,  304,  175,  304,  445,  175,  257,  349,
697       257,  349,  342,  342,  342,  444,  380,  326,  380,  303,
698
699       304,  381,  381,  381,  304,  175,  349,  443,  175,  442,
700       349,  305,  383,  305,  383,  441,  440,  196,  439,  197,
701       197,  197,  307,  307,  307,  344,  344,  344,  326,  198,
702       305,  383,  305,  382,  305,  382,  438,  437,  305,  383,
703       436,  435,  410,  350,  410,  350,  198,  411,  411,  411,
704       382,  305,  175,  434,  382,  348,  348,  348,  175,  305,
705       175,  175,  350,  342,  342,  342,  377,  377,  377,  429,
706       350,  411,  411,  411,  308,  308,  308,  344,  344,  344,
707       348,  348,  348,  308,  308,  308,  428,  427,  256,  426,
708       256,  260,  425,  260,  424,  282,  423,  308,  308,  308,
709
710       308,  308,  308,  175,  422,  256,  175,  421,  260,  256,
711       420,  419,  260,  282,  418,  196,  417,  201,  201,  201,
712       377,  377,  377,  416,  175,  175,  415,  198,  414,  326,
713       199,  300,  199,  300,  430,  408,  430,  407,  406,  431,
714       431,  431,  405,  404,  198,  175,  403,  402,  300,  199,
715       175,  383,  300,  383,  401,  400,  399,  199,  175,  381,
716       381,  381,  326,  398,  381,  381,  381,  397,  396,  395,
717       383,  394,  302,  302,  302,  304,  393,  304,  383,  175,
718       392,  391,  378,  379,  390,  379,  389,  388,  387,  386,
719       385,  326,  304,  431,  431,  431,  304,  384,  175,  378,
720
721       379,  411,  411,  411,  379,  175,  175,  175,  175,  175,
722       175,  282,  346,  375,  346,  374,  373,  372,  371,  431,
723       431,  431,  370,  369,  368,  367,  366,  282,  365,  346,
724       379,  364,  379,  346,  363,  362,  361,  360,  359,  358,
725       357,  356,  355,  354,  353,  352,  282,  379,  351,  175,
726       175,  379,  102,  102,  102,  102,  102,  102,  102,  102,
727       105,  105,  105,  105,  105,  105,  105,  105,  115,  115,
728       115,  340,  115,  115,  115,  115,  141,  339,  141,  174,
729       174,  174,  174,  174,  174,  338,  174,  181,  181,  181,
730       181,  181,  181,  181,  181,  240,  337,  240,  240,  336,
731
732       240,  240,  240,  241,  333,  241,  241,  241,  241,  241,
733       241,  244,  332,  329,  244,  244,  244,  244,  244,  245,
734       245,  245,  245,  245,  245,  245,  245,  257,  324,  257,
735       257,  257,  257,  257,  257,  301,  301,  301,  301,  301,
736       301,  301,  301,  323,  322,  321,  320,  319,  318,  317,
737       316,  315,  314,  313,  312,  175,  311,  175,  175,  175,
738       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
739       175,  175,  175,  175,  175,  296,  295,  294,  293,  292,
740       289,  288,  285,  280,  279,  278,  277,  276,  275,  274,
741       273,  272,  271,  270,  269,  268,  267,  116,  266,  265,
742
743       254,  175,  237,  236,  229,  228,  227,  224,  212,  175,
744       175,  175,  210,  209,  175,  175,  175,  175,  175,  175,
745       175,  175,  171,  170,  169,  162,  161,  160,  157,  145,
746       144,  143,  142,  138,  117,  116,  109,  480,    7,  480,
747       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
748       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
749       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
750       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
751       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
752       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
753
754       480,  480,  480,  480
755     } ;
756
757 static yyconst flex_int16_t yy_chk[1105] =
758     {   0,
759         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
760         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
761         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
762         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
763         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
764         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
765         1,    1,    1,    1,    1,    2,    2,    2,    2,    2,
766         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
767         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
768         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
769
770         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
771         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
772         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
773         3,    4,    5,    6,    5,    6,   13,   13,    3,    4,
774        14,   19,   30,   30,   21,   45,   28,   21,   21,   21,
775       162,   45,   19,   21,   21,   22,   14,   22,   22,   22,
776       162,   23,   28,   28,    5,    6,   23,   25,   25,   25,
777        54,  492,   40,   23,   42,  476,   42,   13,   24,   40,
778        24,   24,   24,   25,   40,   89,   41,   89,   43,   59,
779        24,   49,   49,   24,   41,   24,   24,   43,   50,   66,
780
781        49,   61,   41,   49,   50,   43,  115,   24,   63,   59,
782        54,   62,   24,   63,   67,   62,   71,  159,  159,   66,
783        24,   61,   61,   67,   71,   75,   63,   69,   75,   71,
784        76,   62,  165,  115,   67,   77,   71,   70,   69,   84,
785        63,   69,   69,   69,   75,   75,  165,   69,   69,   70,
786        76,   70,   70,   70,   87,   77,   77,   88,   92,   84,
787       472,   87,   61,   90,   92,   88,   87,   63,   97,   63,
788        72,  100,   90,   88,   97,  469,  104,  182,   96,   96,
789        90,  104,   72,  116,   72,   72,   72,   96,  116,  160,
790        96,  100,  462,  130,   72,  130,  130,   72,  160,   72,
791
792        72,  121,  121,  121,  182,  191,  226,  226,  108,  108,
793       108,   72,  130,  227,  461,  460,   72,  191,  203,  229,
794       130,  131,  227,  131,   72,   73,  131,  131,  131,  229,
795       459,  100,  108,  125,  125,  125,  108,   73,  203,   73,
796        73,   73,  108,  125,  125,  108,  125,  108,  132,   73,
797       132,  261,   73,  261,   73,  232,  207,  241,  188,  242,
798       125,  125,  241,  452,  242,  125,   73,  132,  353,  232,
799       261,   73,  188,  188,  188,  132,  207,  353,  261,   73,
800        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
801        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
802
803       451,   79,   79,   79,   79,   79,   79,   79,   79,   79,
804        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
805        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
806        79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
807        79,  386,   79,  181,   79,  129,  129,  129,  181,  183,
808       386,  199,  450,  194,  198,  129,  129,  412,  129,  448,
809       447,  181,  446,  198,  445,  198,  412,  183,  198,  198,
810       198,  194,  129,  129,  264,  181,  264,  129,  199,  444,
811       199,  209,  246,  246,  246,  443,  209,  247,  247,  247,
812       262,  262,  262,  264,  341,  341,  341,  199,  440,  209,
813
814       439,  264,  181,  437,  181,  199,  436,  435,  183,  433,
815       183,  192,  194,  209,  194,  255,  306,  255,  428,  427,
816       255,  255,  255,  426,  425,  192,  192,  192,  424,  301,
817       306,  306,  306,  423,  420,  192,  192,  419,  192,  259,
818       209,  259,  209,  417,  259,  259,  259,  301,  416,  258,
819       258,  258,  192,  192,  299,  432,  432,  192,  196,  258,
820       258,  415,  258,  299,  432,  299,  408,  407,  299,  299,
821       299,  405,  196,  196,  196,  404,  258,  258,  263,  263,
822       263,  258,  196,  196,  305,  196,  403,  303,  301,  263,
823       301,  263,  342,  342,  342,  402,  303,  401,  303,  196,
824
825       196,  303,  303,  303,  196,  197,  263,  400,  307,  399,
826       263,  305,  308,  305,  308,  398,  396,  197,  395,  197,
827       197,  197,  307,  307,  307,  343,  343,  343,  394,  197,
828       305,  308,  197,  307,  197,  307,  393,  390,  305,  308,
829       389,  388,  345,  350,  345,  350,  197,  345,  345,  345,
830       307,  197,  376,  387,  307,  347,  347,  347,  382,  197,
831       200,  379,  350,  409,  409,  409,  376,  376,  376,  375,
832       350,  410,  410,  410,  200,  200,  200,  344,  344,  344,
833       348,  348,  348,  200,  200,  200,  374,  372,  344,  371,
834       344,  348,  370,  348,  369,  368,  367,  200,  200,  200,
835
836       200,  200,  200,  201,  366,  344,  377,  365,  348,  344,
837       363,  362,  348,  361,  360,  201,  357,  201,  201,  201,
838       377,  377,  377,  356,  383,  378,  355,  201,  354,  340,
839       201,  377,  201,  377,  378,  339,  378,  338,  337,  378,
840       378,  378,  336,  335,  201,  380,  334,  333,  377,  201,
841       381,  383,  377,  383,  332,  331,  329,  201,  302,  380,
842       380,  380,  328,  327,  381,  381,  381,  325,  324,  323,
843       383,  322,  302,  302,  302,  381,  321,  381,  383,  430,
844       320,  319,  302,  302,  318,  302,  317,  316,  315,  314,
845       313,  312,  381,  430,  430,  430,  381,  311,  310,  302,
846
847       302,  411,  411,  411,  302,  431,  309,  304,  300,  298,
848       297,  296,  411,  295,  411,  294,  293,  292,  291,  431,
849       431,  431,  290,  289,  288,  287,  285,  284,  283,  411,
850       431,  281,  431,  411,  280,  279,  278,  277,  276,  275,
851       274,  273,  272,  271,  270,  269,  268,  431,  267,  239,
852       238,  431,  481,  481,  481,  481,  481,  481,  481,  481,
853       482,  482,  482,  482,  482,  482,  482,  482,  483,  483,
854       483,  237,  483,  483,  483,  483,  484,  236,  484,  485,
855       485,  485,  485,  485,  485,  235,  485,  486,  486,  486,
856       486,  486,  486,  486,  486,  487,  234,  487,  487,  233,
857
858       487,  487,  487,  488,  231,  488,  488,  488,  488,  488,
859       488,  489,  230,  228,  489,  489,  489,  489,  489,  490,
860       490,  490,  490,  490,  490,  490,  490,  491,  224,  491,
861       491,  491,  491,  491,  491,  493,  493,  493,  493,  493,
862       493,  493,  493,  223,  222,  221,  220,  219,  218,  217,
863       216,  215,  214,  213,  212,  211,  210,  206,  205,  204,
864       202,  195,  193,  190,  189,  187,  186,  185,  184,  180,
865       179,  178,  177,  176,  174,  170,  169,  168,  167,  166,
866       164,  163,  161,  157,  156,  155,  154,  153,  152,  151,
867       150,  149,  148,  147,  146,  145,  143,  142,  140,  136,
868
869       124,  101,   99,   98,   95,   94,   93,   91,   86,   85,
870        83,   82,   81,   80,   78,   74,   68,   65,   64,   60,
871        58,   57,   53,   52,   51,   48,   47,   46,   44,   39,
872        37,   34,   33,   29,   18,   15,   11,    7,  480,  480,
873       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
874       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
875       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
876       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
877       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
878       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
879
880       480,  480,  480,  480
881     } ;
882
883 /* Table of booleans, true if rule could match eol. */
884 static yyconst flex_int32_t yy_rule_can_match_eol[108] =
885     {   0,
886 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
887     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 
888     0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
889     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
890     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
891     0, 0, 0, 0, 1, 1, 0, 0,     };
892
893 static yy_state_type yy_last_accepting_state;
894 static char *yy_last_accepting_cpos;
895
896 extern int dynC_flex_debug;
897 int dynC_flex_debug = 0;
898
899 /* The intent behind this definition is that it'll catch
900  * any uses of REJECT which flex missed.
901  */
902 #define REJECT reject_used_but_not_detected
903 #define yymore() yymore_used_but_not_detected
904 #define YY_MORE_ADJ 0
905 #define YY_RESTORE_YY_MORE_OFFSET
906 char *dynCtext;
907 #line 1 "C.l"
908
909
910 #line 17 "C.l"
911
912 #include <stdio.h>
913 #include <string>
914 #include "BPatch_snippet.h"
915 #include <vector>
916 #include "dynC.tab.h"
917 #include "snippetGen.h"
918
919 int line_num = 1;
920
921 extern "C" {
922   void set_lex_input(char *);
923 }
924
925 std::string lineStr;
926 static char *input_str = NULL;  
927
928
929 int yycolumn = 0;
930
931 extern bool fatalError;
932
933
934
935 #define YY_USER_ACTION dynClloc.first_line = dynClloc.last_line = line_num;\
936         dynClloc.first_column = yycolumn; dynClloc.last_column = yycolumn+dynCleng-1;\
937         yycolumn += dynCleng;\
938         lineStr = dynCtext;
939
940 #define input() (*input_str++)
941 //#define yyinput() (*input_str++)
942 #define yylval dynClval
943
944 std::string c_string_buf = "";
945
946 const bool lexVerbose = false; // set to true for debug mode
947
948 //"$"{L}({L}|{D})* { yylval.sval = &dynCtext[1]; return(DYNINST_CALL); }
949
950 #line 951 "lex.dynC.C"
951
952 #define INITIAL 0
953 #define comment 1
954 #define stringmode 2
955
956 #ifndef YY_NO_UNISTD_H
957 /* Special case for "unistd.h", since it is non-ANSI. We include it way
958  * down here because we want the user's section 1 to have been scanned first.
959  * The user has a chance to override it with an option.
960  */
961 #include <unistd.h>
962 #endif
963
964 #ifndef YY_EXTRA_TYPE
965 #define YY_EXTRA_TYPE void *
966 #endif
967
968 static int yy_init_globals (void );
969
970 /* Accessor methods to globals.
971    These are made visible to non-reentrant scanners for convenience. */
972
973 int dynClex_destroy (void );
974
975 int dynCget_debug (void );
976
977 void dynCset_debug (int debug_flag  );
978
979 YY_EXTRA_TYPE dynCget_extra (void );
980
981 void dynCset_extra (YY_EXTRA_TYPE user_defined  );
982
983 FILE *dynCget_in (void );
984
985 void dynCset_in  (FILE * _in_str  );
986
987 FILE *dynCget_out (void );
988
989 void dynCset_out  (FILE * _out_str  );
990
991                         int dynCget_leng (void );
992
993 char *dynCget_text (void );
994
995 int dynCget_lineno (void );
996
997 void dynCset_lineno (int _line_number  );
998
999 /* Macros after this point can all be overridden by user definitions in
1000  * section 1.
1001  */
1002
1003 #ifndef YY_SKIP_YYWRAP
1004 #ifdef __cplusplus
1005 extern "C" int dynCwrap (void );
1006 #else
1007 extern int dynCwrap (void );
1008 #endif
1009 #endif
1010
1011 #ifndef YY_NO_UNPUT
1012
1013 #endif
1014
1015 #ifndef yytext_ptr
1016 static void yy_flex_strncpy (char *,yyconst char *,int );
1017 #endif
1018
1019 #ifdef YY_NEED_STRLEN
1020 static int yy_flex_strlen (yyconst char * );
1021 #endif
1022
1023 #ifndef YY_NO_INPUT
1024
1025 #ifdef __cplusplus
1026 static int yyinput (void );
1027 #else
1028 static int input (void );
1029 #endif
1030
1031 #endif
1032
1033 /* Amount of stuff to slurp up with each read. */
1034 #ifndef YY_READ_BUF_SIZE
1035 #ifdef __ia64__
1036 /* On IA-64, the buffer size is 16k, not 8k */
1037 #define YY_READ_BUF_SIZE 16384
1038 #else
1039 #define YY_READ_BUF_SIZE 8192
1040 #endif /* __ia64__ */
1041 #endif
1042
1043 /* Copy whatever the last rule matched to the standard output. */
1044 #ifndef ECHO
1045 /* This used to be an fputs(), but since the string might contain NUL's,
1046  * we now use fwrite().
1047  */
1048 #define ECHO do { if (fwrite( dynCtext, (size_t) dynCleng, 1, dynCout )) {} } while (0)
1049 #endif
1050
1051 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1052  * is returned in "result".
1053  */
1054 #ifndef YY_INPUT
1055 #define YY_INPUT(buf,result,max_size) \
1056         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1057                 { \
1058                 int c = '*'; \
1059                 size_t n; \
1060                 for ( n = 0; n < max_size && \
1061                              (c = getc( dynCin )) != EOF && c != '\n'; ++n ) \
1062                         buf[n] = (char) c; \
1063                 if ( c == '\n' ) \
1064                         buf[n++] = (char) c; \
1065                 if ( c == EOF && ferror( dynCin ) ) \
1066                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1067                 result = n; \
1068                 } \
1069         else \
1070                 { \
1071                 errno=0; \
1072                 while ( (result = (int) fread(buf, 1, max_size, dynCin))==0 && ferror(dynCin)) \
1073                         { \
1074                         if( errno != EINTR) \
1075                                 { \
1076                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1077                                 break; \
1078                                 } \
1079                         errno=0; \
1080                         clearerr(dynCin); \
1081                         } \
1082                 }\
1083 \
1084
1085 #endif
1086
1087 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1088  * we don't want an extra ';' after the "return" because that will cause
1089  * some compilers to complain about unreachable statements.
1090  */
1091 #ifndef yyterminate
1092 #define yyterminate() return YY_NULL
1093 #endif
1094
1095 /* Number of entries by which start-condition stack grows. */
1096 #ifndef YY_START_STACK_INCR
1097 #define YY_START_STACK_INCR 25
1098 #endif
1099
1100 /* Report a fatal error. */
1101 #ifndef YY_FATAL_ERROR
1102 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1103 #endif
1104
1105 /* end tables serialization structures and prototypes */
1106
1107 /* Default declaration of generated scanner - a define so the user can
1108  * easily add parameters.
1109  */
1110 #ifndef YY_DECL
1111 #define YY_DECL_IS_OURS 1
1112
1113 extern int dynClex (void);
1114
1115 #define YY_DECL int dynClex (void)
1116 #endif /* !YY_DECL */
1117
1118 /* Code executed at the beginning of each rule, after dynCtext and dynCleng
1119  * have been set up.
1120  */
1121 #ifndef YY_USER_ACTION
1122 #define YY_USER_ACTION
1123 #endif
1124
1125 /* Code executed at the end of each rule. */
1126 #ifndef YY_BREAK
1127 #define YY_BREAK /*LINTED*/break;
1128 #endif
1129
1130 #define YY_RULE_SETUP \
1131         if ( dynCleng > 0 ) \
1132                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1133                                 (dynCtext[dynCleng - 1] == '\n'); \
1134         YY_USER_ACTION
1135
1136 /** The main scanner function which does all the work.
1137  */
1138 YY_DECL
1139 {
1140         yy_state_type yy_current_state;
1141         char *yy_cp, *yy_bp;
1142         int yy_act;
1143     
1144         if ( !(yy_init) )
1145                 {
1146                 (yy_init) = 1;
1147
1148 #ifdef YY_USER_INIT
1149                 YY_USER_INIT;
1150 #endif
1151
1152                 if ( ! (yy_start) )
1153                         (yy_start) = 1; /* first start state */
1154
1155                 if ( ! dynCin )
1156                         dynCin = stdin;
1157
1158                 if ( ! dynCout )
1159                         dynCout = stdout;
1160
1161                 if ( ! YY_CURRENT_BUFFER ) {
1162                         dynCensure_buffer_stack ();
1163                         YY_CURRENT_BUFFER_LVALUE =
1164                                 dynC_create_buffer(dynCin,YY_BUF_SIZE );
1165                 }
1166
1167                 dynC_load_buffer_state( );
1168                 }
1169
1170         {
1171 #line 58 "C.l"
1172
1173
1174 #line 1175 "lex.dynC.C"
1175
1176         while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
1177                 {
1178                 yy_cp = (yy_c_buf_p);
1179
1180                 /* Support of dynCtext. */
1181                 *yy_cp = (yy_hold_char);
1182
1183                 /* yy_bp points to the position in yy_ch_buf of the start of
1184                  * the current run.
1185                  */
1186                 yy_bp = yy_cp;
1187
1188                 yy_current_state = (yy_start);
1189                 yy_current_state += YY_AT_BOL();
1190 yy_match:
1191                 do
1192                         {
1193                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1194                         if ( yy_accept[yy_current_state] )
1195                                 {
1196                                 (yy_last_accepting_state) = yy_current_state;
1197                                 (yy_last_accepting_cpos) = yy_cp;
1198                                 }
1199                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1200                                 {
1201                                 yy_current_state = (int) yy_def[yy_current_state];
1202                                 if ( yy_current_state >= 481 )
1203                                         yy_c = yy_meta[(unsigned int) yy_c];
1204                                 }
1205                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1206                         ++yy_cp;
1207                         }
1208                 while ( yy_base[yy_current_state] != 1039 );
1209
1210 yy_find_action:
1211                 yy_act = yy_accept[yy_current_state];
1212                 if ( yy_act == 0 )
1213                         { /* have to back up */
1214                         yy_cp = (yy_last_accepting_cpos);
1215                         yy_current_state = (yy_last_accepting_state);
1216                         yy_act = yy_accept[yy_current_state];
1217                         }
1218
1219                 YY_DO_BEFORE_ACTION;
1220
1221                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1222                         {
1223                         yy_size_t yyl;
1224                         for ( yyl = 0; yyl < dynCleng; ++yyl )
1225                                 if ( dynCtext[yyl] == '\n' )
1226                                            
1227     dynClineno++;
1228 ;
1229                         }
1230
1231 do_action:      /* This label is used only to access EOF actions. */
1232
1233                 switch ( yy_act )
1234         { /* beginning of action switch */
1235                         case 0: /* must back up */
1236                         /* undo the effects of YY_DO_BEFORE_ACTION */
1237                         *yy_cp = (yy_hold_char);
1238                         yy_cp = (yy_last_accepting_cpos);
1239                         yy_current_state = (yy_last_accepting_state);
1240                         goto yy_find_action;
1241
1242 case 1:
1243 YY_RULE_SETUP
1244 #line 62 "C.l"
1245 /* eat anything that's not a '*' */ 
1246         YY_BREAK
1247 case 2:
1248 YY_RULE_SETUP
1249 #line 63 "C.l"
1250 /* eat up '*'s not followed by '/'s */                           
1251         YY_BREAK
1252 case 3:
1253 /* rule 3 can match eol */
1254 YY_RULE_SETUP
1255 #line 64 "C.l"
1256 ++line_num;                                                      
1257         YY_BREAK
1258 case 4:
1259 YY_RULE_SETUP
1260 #line 65 "C.l"
1261 BEGIN(INITIAL);       
1262         YY_BREAK
1263 case YY_STATE_EOF(comment):
1264 #line 66 "C.l"
1265 {yylval.context = "Syntax Error: Unterminated block comment"; return(D_ERROR);}
1266         YY_BREAK
1267
1268 case 5:
1269 YY_RULE_SETUP
1270 #line 69 "C.l"
1271 { if(lexVerbose)printf("Inline Comment\n") /* inline comment */;}                            
1272         YY_BREAK
1273 case 6:
1274 YY_RULE_SETUP
1275 #line 70 "C.l"
1276 { BEGIN(comment); }                                                  
1277         YY_BREAK
1278 case 7:
1279 YY_RULE_SETUP
1280 #line 72 "C.l"
1281 { yylval.sval = strdup(dynCtext); return TYPE;}
1282         YY_BREAK
1283 case 8:
1284 YY_RULE_SETUP
1285 #line 73 "C.l"
1286 {yylval.sval = strdup("char *"); return TYPE; }
1287         YY_BREAK
1288 case 9:
1289 YY_RULE_SETUP
1290 #line 75 "C.l"
1291 {return STRUCT; }
1292         YY_BREAK
1293 case 10:
1294 YY_RULE_SETUP
1295 #line 76 "C.l"
1296 {return UNION; }
1297         YY_BREAK
1298 case 11:
1299 YY_RULE_SETUP
1300 #line 77 "C.l"
1301 {return ENUM; }
1302         YY_BREAK
1303 case 12:
1304 YY_RULE_SETUP
1305 #line 79 "C.l"
1306 { return(CASE); }
1307         YY_BREAK
1308 case 13:
1309 YY_RULE_SETUP
1310 #line 80 "C.l"
1311 { return(D_CONST); }
1312         YY_BREAK
1313 case 14:
1314 YY_RULE_SETUP
1315 #line 81 "C.l"
1316 { return(DEFAULT); }
1317         YY_BREAK
1318 case 15:
1319 YY_RULE_SETUP
1320 #line 82 "C.l"
1321 { return(ELSE); }
1322         YY_BREAK
1323 case 16:
1324 YY_RULE_SETUP
1325 #line 83 "C.l"
1326 { return(IF); }
1327         YY_BREAK
1328 case 17:
1329 YY_RULE_SETUP
1330 #line 84 "C.l"
1331 { return(RETURN); }
1332         YY_BREAK
1333 case 18:
1334 YY_RULE_SETUP
1335 #line 85 "C.l"
1336 { return(SIZEOF); }
1337         YY_BREAK
1338 case 19:
1339 YY_RULE_SETUP
1340 #line 86 "C.l"
1341 { return(STATIC); }
1342         YY_BREAK
1343 case 20:
1344 YY_RULE_SETUP
1345 #line 87 "C.l"
1346 { return(SWITCH); }
1347         YY_BREAK
1348 case 21:
1349 YY_RULE_SETUP
1350 #line 88 "C.l"
1351 { return(TYPEDEF); }
1352         YY_BREAK
1353 case 22:
1354 YY_RULE_SETUP
1355 #line 89 "C.l"
1356 { return(D_TRUE); }
1357         YY_BREAK
1358 case 23:
1359 YY_RULE_SETUP
1360 #line 90 "C.l"
1361 { return(D_FALSE); }
1362         YY_BREAK
1363 case 24:
1364 YY_RULE_SETUP
1365 #line 92 "C.l"
1366 { return(LOCAL); }
1367         YY_BREAK
1368 case 25:
1369 YY_RULE_SETUP
1370 #line 93 "C.l"
1371 { return(PARAM); }
1372         YY_BREAK
1373 case 26:
1374 YY_RULE_SETUP
1375 #line 94 "C.l"
1376 { return(GLOBAL); }
1377         YY_BREAK
1378 case 27:
1379 YY_RULE_SETUP
1380 #line 95 "C.l"
1381 { return(DYNINST); }
1382         YY_BREAK
1383 case 28:
1384 YY_RULE_SETUP
1385 #line 96 "C.l"
1386 { return(INST); }
1387         YY_BREAK
1388 case 29:
1389 YY_RULE_SETUP
1390 #line 97 "C.l"
1391 { return(FUNC); }
1392         YY_BREAK
1393 case 30:
1394 YY_RULE_SETUP
1395 #line 98 "C.l"
1396 { return(FUNC); }
1397         YY_BREAK
1398 case 31:
1399 YY_RULE_SETUP
1400 #line 99 "C.l"
1401 { return(REGISTER); }
1402         YY_BREAK
1403 case 32:
1404 YY_RULE_SETUP
1405 #line 100 "C.l"
1406 {return (NILL); }
1407         YY_BREAK
1408 case 33:
1409 YY_RULE_SETUP
1410 #line 102 "C.l"
1411 {yylval.sval = strdup(dynCtext); if(lexVerbose) printf("ID: %s\n", dynCtext); return(IDENTIFIER); }
1412         YY_BREAK
1413 case 34:
1414 YY_RULE_SETUP
1415 #line 106 "C.l"
1416 { yylval.ival = atoi(dynCtext); return NUMBER;}
1417         YY_BREAK
1418 case 35:
1419 YY_RULE_SETUP
1420 #line 108 "C.l"
1421 { return(CONSTANT); }
1422         YY_BREAK
1423 case 36:
1424 YY_RULE_SETUP
1425 #line 109 "C.l"
1426 { return(CONSTANT); }
1427         YY_BREAK
1428 case 37:
1429 YY_RULE_SETUP
1430 #line 110 "C.l"
1431 { return(CONSTANT); }
1432         YY_BREAK
1433 case 38:
1434 /* rule 38 can match eol */
1435 YY_RULE_SETUP
1436 #line 111 "C.l"
1437 { return(CONSTANT); }
1438         YY_BREAK
1439 case 39:
1440 YY_RULE_SETUP
1441 #line 113 "C.l"
1442 { return(CONSTANT); }
1443         YY_BREAK
1444 case 40:
1445 YY_RULE_SETUP
1446 #line 114 "C.l"
1447 { return(CONSTANT); }
1448         YY_BREAK
1449 case 41:
1450 YY_RULE_SETUP
1451 #line 115 "C.l"
1452 { return(CONSTANT); }
1453         YY_BREAK
1454 case 42:
1455 YY_RULE_SETUP
1456 #line 117 "C.l"
1457 {if(lexVerbose)printf("String Mode!\n"); c_string_buf = ""; BEGIN(stringmode);} 
1458         YY_BREAK
1459
1460 case 43:
1461 YY_RULE_SETUP
1462 #line 121 "C.l"
1463 { /* saw closing quote - all done */
1464                   // this string handling code was taken from the flex manual
1465                   if(lexVerbose)printf("string done\n");
1466                   BEGIN(INITIAL);                                                    
1467                   yylval.sval = strdup(c_string_buf.c_str());
1468                   return STRING;                                                     
1469                 }
1470         YY_BREAK
1471 case 44:
1472 /* rule 44 can match eol */
1473 YY_RULE_SETUP
1474 #line 129 "C.l"
1475 { /* error - unterminated strin constant */
1476                   yylval.context = "Unterminated string constant";
1477                   yycolumn = 1;
1478                   //yylval.line_number = line_num;                                                     line_num++;
1479                   return D_ERROR;
1480                 }
1481         YY_BREAK
1482 case 45:
1483 YY_RULE_SETUP
1484 #line 136 "C.l"
1485 { /* octal escape sequence */
1486                   int result;                                                        
1487                   (void) sscanf( dynCtext + 1, "%o", &result );                        
1488                   if ( result > 0xff ){
1489                       /* error, constant is out-of-bounds */
1490                       yylval.context = "constant out of bounds";                
1491                      // yylval.line_number = line_num;                            
1492                       return D_ERROR;
1493                   }
1494                   c_string_buf += result;                                            
1495   
1496                 }
1497         YY_BREAK
1498 case 46:
1499 YY_RULE_SETUP
1500 #line 149 "C.l"
1501 { /* generate error - bad escape sequence */
1502                   yylval.context = "bad escape sequence";                       
1503                  // yylval.line_number = line_num;                                
1504                   return D_ERROR;
1505                 }
1506         YY_BREAK
1507 case 47:
1508 YY_RULE_SETUP
1509 #line 154 "C.l"
1510 c_string_buf += '\n';                                                
1511         YY_BREAK
1512 case 48:
1513 YY_RULE_SETUP
1514 #line 155 "C.l"
1515 c_string_buf += '\t';                                                
1516         YY_BREAK
1517 case 49:
1518 YY_RULE_SETUP
1519 #line 156 "C.l"
1520 c_string_buf += '\r';                                                
1521         YY_BREAK
1522 case 50:
1523 YY_RULE_SETUP
1524 #line 157 "C.l"
1525 c_string_buf += '\b';                                             
1526         YY_BREAK
1527 case 51:
1528 YY_RULE_SETUP
1529 #line 158 "C.l"
1530 c_string_buf += '\f';                                                
1531         YY_BREAK
1532 case 52:
1533 /* rule 52 can match eol */
1534 YY_RULE_SETUP
1535 #line 160 "C.l"
1536 c_string_buf += dynCtext[1];
1537         YY_BREAK
1538 case 53:
1539 YY_RULE_SETUP
1540 #line 161 "C.l"
1541 {
1542                   char *yptr = dynCtext;
1543                   while ( *yptr ) { c_string_buf += *yptr++; }
1544                 }
1545         YY_BREAK
1546
1547 case 54:
1548 YY_RULE_SETUP
1549 #line 168 "C.l"
1550 { return(ELLIPSIS); }
1551         YY_BREAK
1552 case 55:
1553 YY_RULE_SETUP
1554 #line 169 "C.l"
1555 { return(RIGHT_ASSIGN); }
1556         YY_BREAK
1557 case 56:
1558 YY_RULE_SETUP
1559 #line 170 "C.l"
1560 { return(LEFT_ASSIGN); }
1561         YY_BREAK
1562 case 57:
1563 YY_RULE_SETUP
1564 #line 171 "C.l"
1565 { return(ADD_ASSIGN); }
1566         YY_BREAK
1567 case 58:
1568 YY_RULE_SETUP
1569 #line 172 "C.l"
1570 { return(SUB_ASSIGN); }
1571         YY_BREAK
1572 case 59:
1573 YY_RULE_SETUP
1574 #line 173 "C.l"
1575 { return(MUL_ASSIGN); }
1576         YY_BREAK
1577 case 60:
1578 YY_RULE_SETUP
1579 #line 174 "C.l"
1580 { return(DIV_ASSIGN); }
1581         YY_BREAK
1582 case 61:
1583 YY_RULE_SETUP
1584 #line 175 "C.l"
1585 { return(MOD_ASSIGN); }
1586         YY_BREAK
1587 case 62:
1588 YY_RULE_SETUP
1589 #line 176 "C.l"
1590 { return(AND_ASSIGN); }
1591         YY_BREAK
1592 case 63:
1593 YY_RULE_SETUP
1594 #line 177 "C.l"
1595 { return(XOR_ASSIGN); }
1596         YY_BREAK
1597 case 64:
1598 YY_RULE_SETUP
1599 #line 178 "C.l"
1600 { return(OR_ASSIGN); }
1601         YY_BREAK
1602 case 65:
1603 YY_RULE_SETUP
1604 #line 179 "C.l"
1605 { return(RIGHT_OP); }
1606         YY_BREAK
1607 case 66:
1608 YY_RULE_SETUP
1609 #line 180 "C.l"
1610 { return(LEFT_OP); }
1611         YY_BREAK
1612 case 67:
1613 YY_RULE_SETUP
1614 #line 181 "C.l"
1615 { return(INC_OP); }
1616         YY_BREAK
1617 case 68:
1618 YY_RULE_SETUP
1619 #line 182 "C.l"
1620 { return(DEC_OP); }
1621         YY_BREAK
1622 case 69:
1623 YY_RULE_SETUP
1624 #line 183 "C.l"
1625 { return(PTR_OP); }
1626         YY_BREAK
1627 case 70:
1628 YY_RULE_SETUP
1629 #line 184 "C.l"
1630 { return(AND); }
1631         YY_BREAK
1632 case 71:
1633 YY_RULE_SETUP
1634 #line 185 "C.l"
1635 { return(OR); }
1636         YY_BREAK
1637 case 72:
1638 YY_RULE_SETUP
1639 #line 186 "C.l"
1640 { return(LESS_EQ); }
1641         YY_BREAK
1642 case 73:
1643 YY_RULE_SETUP
1644 #line 187 "C.l"
1645 { return(GREATER_EQ); }
1646         YY_BREAK
1647 case 74:
1648 YY_RULE_SETUP
1649 #line 188 "C.l"
1650 { return(EQ); }
1651         YY_BREAK
1652 case 75:
1653 YY_RULE_SETUP
1654 #line 189 "C.l"
1655 { return(NOT_EQ); }
1656         YY_BREAK
1657 case 76:
1658 YY_RULE_SETUP
1659 #line 190 "C.l"
1660 { return(SEMI); }
1661         YY_BREAK
1662 case 77:
1663 YY_RULE_SETUP
1664 #line 191 "C.l"
1665 { return('{'); }
1666         YY_BREAK
1667 case 78:
1668 YY_RULE_SETUP
1669 #line 192 "C.l"
1670 { return('}'); }
1671         YY_BREAK
1672 case 79:
1673 YY_RULE_SETUP
1674 #line 193 "C.l"
1675 { return(NOPEN); }
1676         YY_BREAK
1677 case 80:
1678 YY_RULE_SETUP
1679 #line 194 "C.l"
1680 { return(NCLOSE); }
1681         YY_BREAK
1682 case 81:
1683 YY_RULE_SETUP
1684 #line 195 "C.l"
1685 { return(COMMA); }
1686         YY_BREAK
1687 case 82:
1688 YY_RULE_SETUP
1689 #line 196 "C.l"
1690 { return(COLON); }
1691         YY_BREAK
1692 case 83:
1693 YY_RULE_SETUP
1694 #line 197 "C.l"
1695 { return(ASSIGN); }
1696         YY_BREAK
1697 case 84:
1698 YY_RULE_SETUP
1699 #line 198 "C.l"
1700 { if(lexVerbose)printf("(\n"); return('('); }
1701         YY_BREAK
1702 case 85:
1703 YY_RULE_SETUP
1704 #line 199 "C.l"
1705 { if(lexVerbose)printf(")\n"); return(')'); }
1706         YY_BREAK
1707 case 86:
1708 YY_RULE_SETUP
1709 #line 200 "C.l"
1710 { return('['); }
1711         YY_BREAK
1712 case 87:
1713 YY_RULE_SETUP
1714 #line 201 "C.l"
1715 { return(']'); }
1716         YY_BREAK
1717 case 88:
1718 YY_RULE_SETUP
1719 #line 202 "C.l"
1720 { return(DOT); }
1721         YY_BREAK
1722 case 89:
1723 YY_RULE_SETUP
1724 #line 203 "C.l"
1725 { return('&'); }
1726         YY_BREAK
1727 case 90:
1728 YY_RULE_SETUP
1729 #line 204 "C.l"
1730 { return('!'); }
1731         YY_BREAK
1732 case 91:
1733 YY_RULE_SETUP
1734 #line 205 "C.l"
1735 { return('~'); }
1736         YY_BREAK
1737 case 92:
1738 YY_RULE_SETUP
1739 #line 206 "C.l"
1740 { return('-'); }
1741         YY_BREAK
1742 case 93:
1743 YY_RULE_SETUP
1744 #line 207 "C.l"
1745 { return('+'); }
1746         YY_BREAK
1747 case 94:
1748 YY_RULE_SETUP
1749 #line 208 "C.l"
1750 { return('*'); }
1751         YY_BREAK
1752 case 95:
1753 YY_RULE_SETUP
1754 #line 209 "C.l"
1755 { return('/'); }
1756         YY_BREAK
1757 case 96:
1758 YY_RULE_SETUP
1759 #line 210 "C.l"
1760 { return('%'); }
1761         YY_BREAK
1762 case 97:
1763 YY_RULE_SETUP
1764 #line 211 "C.l"
1765 { return('<'); }
1766         YY_BREAK
1767 case 98:
1768 YY_RULE_SETUP
1769 #line 212 "C.l"
1770 { return('>'); }
1771         YY_BREAK
1772 case 99:
1773 YY_RULE_SETUP
1774 #line 213 "C.l"
1775 { return('^'); }
1776         YY_BREAK
1777 case 100:
1778 YY_RULE_SETUP
1779 #line 214 "C.l"
1780 { return('|'); }
1781         YY_BREAK
1782 case 101:
1783 YY_RULE_SETUP
1784 #line 215 "C.l"
1785 { return('?'); }
1786         YY_BREAK
1787 case 102:
1788 YY_RULE_SETUP
1789 #line 216 "C.l"
1790 { if(lexVerbose)printf("Backtick\n"); return(BACKTICK); }
1791         YY_BREAK
1792 case 103:
1793 YY_RULE_SETUP
1794 #line 217 "C.l"
1795 { }
1796         YY_BREAK
1797 case 104:
1798 /* rule 104 can match eol */
1799 YY_RULE_SETUP
1800 #line 219 "C.l"
1801 {if(strstr(dynCtext, "//") != NULL){++line_num;}else{if(strncmp(dynCtext,"/*", 2) == 0){BEGIN(comment);++line_num;}else{if(lexVerbose)printf("No Semi!\n"); fatalError = true; dynClloc.first_column = yycolumn; yylval.context = "syntax error: missing ';'!"; yyless(dynCleng - 1); return(D_ERROR);}}}
1802         YY_BREAK
1803 case 105:
1804 /* rule 105 can match eol */
1805 YY_RULE_SETUP
1806 #line 221 "C.l"
1807 {if(lexVerbose)printf("New Line!\n"); line_num++; yycolumn = 0; lineStr = "";}
1808         YY_BREAK
1809 case 106:
1810 YY_RULE_SETUP
1811 #line 223 "C.l"
1812 { if(lexVerbose) printf("Unrecognized [%s]\n", dynCtext); /* ignore bad characters */ }
1813         YY_BREAK
1814 case 107:
1815 YY_RULE_SETUP
1816 #line 227 "C.l"
1817 ECHO;
1818         YY_BREAK
1819 #line 1820 "lex.dynC.C"
1820 case YY_STATE_EOF(INITIAL):
1821 case YY_STATE_EOF(stringmode):
1822         yyterminate();
1823
1824         case YY_END_OF_BUFFER:
1825                 {
1826                 /* Amount of text matched not including the EOB char. */
1827                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1828
1829                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1830                 *yy_cp = (yy_hold_char);
1831                 YY_RESTORE_YY_MORE_OFFSET
1832
1833                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1834                         {
1835                         /* We're scanning a new file or input source.  It's
1836                          * possible that this happened because the user
1837                          * just pointed dynCin at a new source and called
1838                          * dynClex().  If so, then we have to assure
1839                          * consistency between YY_CURRENT_BUFFER and our
1840                          * globals.  Here is the right place to do so, because
1841                          * this is the first action (other than possibly a
1842                          * back-up) that will match for the new input source.
1843                          */
1844                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1845                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = dynCin;
1846                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1847                         }
1848
1849                 /* Note that here we test for yy_c_buf_p "<=" to the position
1850                  * of the first EOB in the buffer, since yy_c_buf_p will
1851                  * already have been incremented past the NUL character
1852                  * (since all states make transitions on EOB to the
1853                  * end-of-buffer state).  Contrast this with the test
1854                  * in input().
1855                  */
1856                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1857                         { /* This was really a NUL. */
1858                         yy_state_type yy_next_state;
1859
1860                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1861
1862                         yy_current_state = yy_get_previous_state(  );
1863
1864                         /* Okay, we're now positioned to make the NUL
1865                          * transition.  We couldn't have
1866                          * yy_get_previous_state() go ahead and do it
1867                          * for us because it doesn't know how to deal
1868                          * with the possibility of jamming (and we don't
1869                          * want to build jamming into it because then it
1870                          * will run more slowly).
1871                          */
1872
1873                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1874
1875                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1876
1877                         if ( yy_next_state )
1878                                 {
1879                                 /* Consume the NUL. */
1880                                 yy_cp = ++(yy_c_buf_p);
1881                                 yy_current_state = yy_next_state;
1882                                 goto yy_match;
1883                                 }
1884
1885                         else
1886                                 {
1887                                 yy_cp = (yy_c_buf_p);
1888                                 goto yy_find_action;
1889                                 }
1890                         }
1891
1892                 else switch ( yy_get_next_buffer(  ) )
1893                         {
1894                         case EOB_ACT_END_OF_FILE:
1895                                 {
1896                                 (yy_did_buffer_switch_on_eof) = 0;
1897
1898                                 if ( dynCwrap( ) )
1899                                         {
1900                                         /* Note: because we've taken care in
1901                                          * yy_get_next_buffer() to have set up
1902                                          * dynCtext, we can now set up
1903                                          * yy_c_buf_p so that if some total
1904                                          * hoser (like flex itself) wants to
1905                                          * call the scanner after we return the
1906                                          * YY_NULL, it'll still work - another
1907                                          * YY_NULL will get returned.
1908                                          */
1909                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1910
1911                                         yy_act = YY_STATE_EOF(YY_START);
1912                                         goto do_action;
1913                                         }
1914
1915                                 else
1916                                         {
1917                                         if ( ! (yy_did_buffer_switch_on_eof) )
1918                                                 YY_NEW_FILE;
1919                                         }
1920                                 break;
1921                                 }
1922
1923                         case EOB_ACT_CONTINUE_SCAN:
1924                                 (yy_c_buf_p) =
1925                                         (yytext_ptr) + yy_amount_of_matched_text;
1926
1927                                 yy_current_state = yy_get_previous_state(  );
1928
1929                                 yy_cp = (yy_c_buf_p);
1930                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1931                                 goto yy_match;
1932
1933                         case EOB_ACT_LAST_MATCH:
1934                                 (yy_c_buf_p) =
1935                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1936
1937                                 yy_current_state = yy_get_previous_state(  );
1938
1939                                 yy_cp = (yy_c_buf_p);
1940                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1941                                 goto yy_find_action;
1942                         }
1943                 break;
1944                 }
1945
1946         default:
1947                 YY_FATAL_ERROR(
1948                         "fatal flex scanner internal error--no action found" );
1949         } /* end of action switch */
1950                 } /* end of scanning one token */
1951         } /* end of user's declarations */
1952 } /* end of dynClex */
1953
1954 /* yy_get_next_buffer - try to read in a new buffer
1955  *
1956  * Returns a code representing an action:
1957  *      EOB_ACT_LAST_MATCH -
1958  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1959  *      EOB_ACT_END_OF_FILE - end of file
1960  */
1961 static int yy_get_next_buffer (void)
1962 {
1963         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1964         char *source = (yytext_ptr);
1965         yy_size_t number_to_move, i;
1966         int ret_val;
1967
1968         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1969                 YY_FATAL_ERROR(
1970                 "fatal flex scanner internal error--end of buffer missed" );
1971
1972         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1973                 { /* Don't try to fill the buffer, so this is an EOF. */
1974                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1975                         {
1976                         /* We matched a single character, the EOB, so
1977                          * treat this as a final EOF.
1978                          */
1979                         return EOB_ACT_END_OF_FILE;
1980                         }
1981
1982                 else
1983                         {
1984                         /* We matched some text prior to the EOB, first
1985                          * process it.
1986                          */
1987                         return EOB_ACT_LAST_MATCH;
1988                         }
1989                 }
1990
1991         /* Try to read more data. */
1992
1993         /* First move last chars to start of buffer. */
1994         number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1995
1996         for ( i = 0; i < number_to_move; ++i )
1997                 *(dest++) = *(source++);
1998
1999         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2000                 /* don't do the read, it's not guaranteed to return an EOF,
2001                  * just force an EOF
2002                  */
2003                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2004
2005         else
2006                 {
2007                         int num_to_read =
2008                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2009
2010                 while ( num_to_read <= 0 )
2011                         { /* Not enough room in the buffer - grow it. */
2012
2013                         /* just a shorter name for the current buffer */
2014                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
2015
2016                         int yy_c_buf_p_offset =
2017                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2018
2019                         if ( b->yy_is_our_buffer )
2020                                 {
2021                                 int new_size = b->yy_buf_size * 2;
2022
2023                                 if ( new_size <= 0 )
2024                                         b->yy_buf_size += b->yy_buf_size / 8;
2025                                 else
2026                                         b->yy_buf_size *= 2;
2027
2028                                 b->yy_ch_buf = (char *)
2029                                         /* Include room in for 2 EOB chars. */
2030                                         dynCrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
2031                                 }
2032                         else
2033                                 /* Can't grow it, we don't own it. */
2034                                 b->yy_ch_buf = NULL;
2035
2036                         if ( ! b->yy_ch_buf )
2037                                 YY_FATAL_ERROR(
2038                                 "fatal error - scanner input buffer overflow" );
2039
2040                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2041
2042                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2043                                                 number_to_move - 1;
2044
2045                         }
2046
2047                 if ( num_to_read > YY_READ_BUF_SIZE )
2048                         num_to_read = YY_READ_BUF_SIZE;
2049
2050                 /* Read in more data. */
2051                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2052                         (yy_n_chars), num_to_read );
2053
2054                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2055                 }
2056
2057         if ( (yy_n_chars) == 0 )
2058                 {
2059                 if ( number_to_move == YY_MORE_ADJ )
2060                         {
2061                         ret_val = EOB_ACT_END_OF_FILE;
2062                         dynCrestart(dynCin  );
2063                         }
2064
2065                 else
2066                         {
2067                         ret_val = EOB_ACT_LAST_MATCH;
2068                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2069                                 YY_BUFFER_EOF_PENDING;
2070                         }
2071                 }
2072
2073         else
2074                 ret_val = EOB_ACT_CONTINUE_SCAN;
2075
2076         if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2077                 /* Extend the array by 50%, plus the number we really need. */
2078                 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2079                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) dynCrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2080                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2081                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2082         }
2083
2084         (yy_n_chars) += number_to_move;
2085         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2086         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2087
2088         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2089
2090         return ret_val;
2091 }
2092
2093 /* yy_get_previous_state - get the state just before the EOB char was reached */
2094
2095     static yy_state_type yy_get_previous_state (void)
2096 {
2097         yy_state_type yy_current_state;
2098         char *yy_cp;
2099     
2100         yy_current_state = (yy_start);
2101         yy_current_state += YY_AT_BOL();
2102
2103         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2104                 {
2105                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2106                 if ( yy_accept[yy_current_state] )
2107                         {
2108                         (yy_last_accepting_state) = yy_current_state;
2109                         (yy_last_accepting_cpos) = yy_cp;
2110                         }
2111                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2112                         {
2113                         yy_current_state = (int) yy_def[yy_current_state];
2114                         if ( yy_current_state >= 481 )
2115                                 yy_c = yy_meta[(unsigned int) yy_c];
2116                         }
2117                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
2118                 }
2119
2120         return yy_current_state;
2121 }
2122
2123 /* yy_try_NUL_trans - try to make a transition on the NUL character
2124  *
2125  * synopsis
2126  *      next_state = yy_try_NUL_trans( current_state );
2127  */
2128     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2129 {
2130         int yy_is_jam;
2131         char *yy_cp = (yy_c_buf_p);
2132
2133         YY_CHAR yy_c = 1;
2134         if ( yy_accept[yy_current_state] )
2135                 {
2136                 (yy_last_accepting_state) = yy_current_state;
2137                 (yy_last_accepting_cpos) = yy_cp;
2138                 }
2139         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2140                 {
2141                 yy_current_state = (int) yy_def[yy_current_state];
2142                 if ( yy_current_state >= 481 )
2143                         yy_c = yy_meta[(unsigned int) yy_c];
2144                 }
2145         yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
2146         yy_is_jam = (yy_current_state == 480);
2147
2148                 return yy_is_jam ? 0 : yy_current_state;
2149 }
2150
2151 #ifndef YY_NO_UNPUT
2152
2153 #endif
2154
2155 #ifndef YY_NO_INPUT
2156 #ifdef __cplusplus
2157     static int yyinput (void)
2158 #else
2159     static int input  (void)
2160 #endif
2161
2162 {
2163         int c;
2164     
2165         *(yy_c_buf_p) = (yy_hold_char);
2166
2167         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2168                 {
2169                 /* yy_c_buf_p now points to the character we want to return.
2170                  * If this occurs *before* the EOB characters, then it's a
2171                  * valid NUL; if not, then we've hit the end of the buffer.
2172                  */
2173                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2174                         /* This was really a NUL. */
2175                         *(yy_c_buf_p) = '\0';
2176
2177                 else
2178                         { /* need more input */
2179                         int offset = (yy_c_buf_p) - (yytext_ptr);
2180                         ++(yy_c_buf_p);
2181
2182                         switch ( yy_get_next_buffer(  ) )
2183                                 {
2184                                 case EOB_ACT_LAST_MATCH:
2185                                         /* This happens because yy_g_n_b()
2186                                          * sees that we've accumulated a
2187                                          * token and flags that we need to
2188                                          * try matching the token before
2189                                          * proceeding.  But for input(),
2190                                          * there's no matching to consider.
2191                                          * So convert the EOB_ACT_LAST_MATCH
2192                                          * to EOB_ACT_END_OF_FILE.
2193                                          */
2194
2195                                         /* Reset buffer status. */
2196                                         dynCrestart(dynCin );
2197
2198                                         /*FALLTHROUGH*/
2199
2200                                 case EOB_ACT_END_OF_FILE:
2201                                         {
2202                                         if ( dynCwrap( ) )
2203                                                 return 0;
2204
2205                                         if ( ! (yy_did_buffer_switch_on_eof) )
2206                                                 YY_NEW_FILE;
2207 #ifdef __cplusplus
2208                                         return yyinput();
2209 #else
2210                                         return input();
2211 #endif
2212                                         }
2213
2214                                 case EOB_ACT_CONTINUE_SCAN:
2215                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2216                                         break;
2217                                 }
2218                         }
2219                 }
2220
2221         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2222         *(yy_c_buf_p) = '\0';   /* preserve dynCtext */
2223         (yy_hold_char) = *++(yy_c_buf_p);
2224
2225         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2226         if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
2227                    
2228     dynClineno++;
2229 ;
2230
2231         return c;
2232 }
2233 #endif  /* ifndef YY_NO_INPUT */
2234
2235 /** Immediately switch to a different input stream.
2236  * @param input_file A readable stream.
2237  * 
2238  * @note This function does not reset the start condition to @c INITIAL .
2239  */
2240     void dynCrestart  (FILE * input_file )
2241 {
2242     
2243         if ( ! YY_CURRENT_BUFFER ){
2244         dynCensure_buffer_stack ();
2245                 YY_CURRENT_BUFFER_LVALUE =
2246             dynC_create_buffer(dynCin,YY_BUF_SIZE );
2247         }
2248
2249         dynC_init_buffer(YY_CURRENT_BUFFER,input_file );
2250         dynC_load_buffer_state( );
2251 }
2252
2253 /** Switch to a different input buffer.
2254  * @param new_buffer The new input buffer.
2255  * 
2256  */
2257     void dynC_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2258 {
2259     
2260         /* TODO. We should be able to replace this entire function body
2261          * with
2262          *              dynCpop_buffer_state();
2263          *              dynCpush_buffer_state(new_buffer);
2264      */
2265         dynCensure_buffer_stack ();
2266         if ( YY_CURRENT_BUFFER == new_buffer )
2267                 return;
2268
2269         if ( YY_CURRENT_BUFFER )
2270                 {
2271                 /* Flush out information for old buffer. */
2272                 *(yy_c_buf_p) = (yy_hold_char);
2273                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2274                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2275                 }
2276
2277         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2278         dynC_load_buffer_state( );
2279
2280         /* We don't actually know whether we did this switch during
2281          * EOF (dynCwrap()) processing, but the only time this flag
2282          * is looked at is after dynCwrap() is called, so it's safe
2283          * to go ahead and always set it.
2284          */
2285         (yy_did_buffer_switch_on_eof) = 1;
2286 }
2287
2288 static void dynC_load_buffer_state  (void)
2289 {
2290         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2291         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2292         dynCin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2293         (yy_hold_char) = *(yy_c_buf_p);
2294 }
2295
2296 /** Allocate and initialize an input buffer state.
2297  * @param file A readable stream.
2298  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2299  * 
2300  * @return the allocated buffer state.
2301  */
2302     YY_BUFFER_STATE dynC_create_buffer  (FILE * file, int  size )
2303 {
2304         YY_BUFFER_STATE b;
2305     
2306         b = (YY_BUFFER_STATE) dynCalloc(sizeof( struct yy_buffer_state )  );
2307         if ( ! b )
2308                 YY_FATAL_ERROR( "out of dynamic memory in dynC_create_buffer()" );
2309
2310         b->yy_buf_size = (yy_size_t)size;
2311
2312         /* yy_ch_buf has to be 2 characters longer than the size given because
2313          * we need to put in 2 end-of-buffer characters.
2314          */
2315         b->yy_ch_buf = (char *) dynCalloc(b->yy_buf_size + 2  );
2316         if ( ! b->yy_ch_buf )
2317                 YY_FATAL_ERROR( "out of dynamic memory in dynC_create_buffer()" );
2318
2319         b->yy_is_our_buffer = 1;
2320
2321         dynC_init_buffer(b,file );
2322
2323         return b;
2324 }
2325
2326 /** Destroy the buffer.
2327  * @param b a buffer created with dynC_create_buffer()
2328  * 
2329  */
2330     void dynC_delete_buffer (YY_BUFFER_STATE  b )
2331 {
2332     
2333         if ( ! b )
2334                 return;
2335
2336         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2337                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2338
2339         if ( b->yy_is_our_buffer )
2340                 dynCfree((void *) b->yy_ch_buf  );
2341
2342         dynCfree((void *) b  );
2343 }
2344
2345 /* Initializes or reinitializes a buffer.
2346  * This function is sometimes called more than once on the same buffer,
2347  * such as during a dynCrestart() or at EOF.
2348  */
2349     static void dynC_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2350
2351 {
2352         int oerrno = errno;
2353     
2354         dynC_flush_buffer(b );
2355
2356         b->yy_input_file = file;
2357         b->yy_fill_buffer = 1;
2358
2359     /* If b is the current buffer, then dynC_init_buffer was _probably_
2360      * called from dynCrestart() or through yy_get_next_buffer.
2361      * In that case, we don't want to reset the lineno or column.
2362      */
2363     if (b != YY_CURRENT_BUFFER){
2364         b->yy_bs_lineno = 1;
2365         b->yy_bs_column = 0;
2366     }
2367
2368         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2369     
2370         errno = oerrno;
2371 }
2372
2373 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2374  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2375  * 
2376  */
2377     void dynC_flush_buffer (YY_BUFFER_STATE  b )
2378 {
2379         if ( ! b )
2380                 return;
2381
2382         b->yy_n_chars = 0;
2383
2384         /* We always need two end-of-buffer characters.  The first causes
2385          * a transition to the end-of-buffer state.  The second causes
2386          * a jam in that state.
2387          */
2388         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2389         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2390
2391         b->yy_buf_pos = &b->yy_ch_buf[0];
2392
2393         b->yy_at_bol = 1;
2394         b->yy_buffer_status = YY_BUFFER_NEW;
2395
2396         if ( b == YY_CURRENT_BUFFER )
2397                 dynC_load_buffer_state( );
2398 }
2399
2400 /** Pushes the new state onto the stack. The new state becomes
2401  *  the current state. This function will allocate the stack
2402  *  if necessary.
2403  *  @param new_buffer The new state.
2404  *  
2405  */
2406 void dynCpush_buffer_state (YY_BUFFER_STATE new_buffer )
2407 {
2408         if (new_buffer == NULL)
2409                 return;
2410
2411         dynCensure_buffer_stack();
2412
2413         /* This block is copied from dynC_switch_to_buffer. */
2414         if ( YY_CURRENT_BUFFER )
2415                 {
2416                 /* Flush out information for old buffer. */
2417                 *(yy_c_buf_p) = (yy_hold_char);
2418                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2419                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2420                 }
2421
2422         /* Only push if top exists. Otherwise, replace top. */
2423         if (YY_CURRENT_BUFFER)
2424                 (yy_buffer_stack_top)++;
2425         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2426
2427         /* copied from dynC_switch_to_buffer. */
2428         dynC_load_buffer_state( );
2429         (yy_did_buffer_switch_on_eof) = 1;
2430 }
2431
2432 /** Removes and deletes the top of the stack, if present.
2433  *  The next element becomes the new top.
2434  *  
2435  */
2436 void dynCpop_buffer_state (void)
2437 {
2438         if (!YY_CURRENT_BUFFER)
2439                 return;
2440
2441         dynC_delete_buffer(YY_CURRENT_BUFFER );
2442         YY_CURRENT_BUFFER_LVALUE = NULL;
2443         if ((yy_buffer_stack_top) > 0)
2444                 --(yy_buffer_stack_top);
2445
2446         if (YY_CURRENT_BUFFER) {
2447                 dynC_load_buffer_state( );
2448                 (yy_did_buffer_switch_on_eof) = 1;
2449         }
2450 }
2451
2452 /* Allocates the stack if it does not exist.
2453  *  Guarantees space for at least one push.
2454  */
2455 static void dynCensure_buffer_stack (void)
2456 {
2457         int num_to_alloc;
2458     
2459         if (!(yy_buffer_stack)) {
2460
2461                 /* First allocation is just for 2 elements, since we don't know if this
2462                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2463                  * immediate realloc on the next call.
2464          */
2465       num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2466                 (yy_buffer_stack) = (struct yy_buffer_state**)dynCalloc
2467                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2468                                                                 );
2469                 if ( ! (yy_buffer_stack) )
2470                         YY_FATAL_ERROR( "out of dynamic memory in dynCensure_buffer_stack()" );
2471                                                                   
2472                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2473                                 
2474                 (yy_buffer_stack_max) = num_to_alloc;
2475                 (yy_buffer_stack_top) = 0;
2476                 return;
2477         }
2478
2479         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2480
2481                 /* Increase the buffer to prepare for a possible push. */
2482                 yy_size_t grow_size = 8 /* arbitrary grow size */;
2483
2484                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2485                 (yy_buffer_stack) = (struct yy_buffer_state**)dynCrealloc
2486                                                                 ((yy_buffer_stack),
2487                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2488                                                                 );
2489                 if ( ! (yy_buffer_stack) )
2490                         YY_FATAL_ERROR( "out of dynamic memory in dynCensure_buffer_stack()" );
2491
2492                 /* zero only the new slots.*/
2493                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2494                 (yy_buffer_stack_max) = num_to_alloc;
2495         }
2496 }
2497
2498 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2499  * @param base the character buffer
2500  * @param size the size in bytes of the character buffer
2501  * 
2502  * @return the newly allocated buffer state object. 
2503  */
2504 YY_BUFFER_STATE dynC_scan_buffer  (char * base, yy_size_t  size )
2505 {
2506         YY_BUFFER_STATE b;
2507     
2508         if ( size < 2 ||
2509              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2510              base[size-1] != YY_END_OF_BUFFER_CHAR )
2511                 /* They forgot to leave room for the EOB's. */
2512                 return NULL;
2513
2514         b = (YY_BUFFER_STATE) dynCalloc(sizeof( struct yy_buffer_state )  );
2515         if ( ! b )
2516                 YY_FATAL_ERROR( "out of dynamic memory in dynC_scan_buffer()" );
2517
2518         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2519         b->yy_buf_pos = b->yy_ch_buf = base;
2520         b->yy_is_our_buffer = 0;
2521         b->yy_input_file = NULL;
2522         b->yy_n_chars = b->yy_buf_size;
2523         b->yy_is_interactive = 0;
2524         b->yy_at_bol = 1;
2525         b->yy_fill_buffer = 0;
2526         b->yy_buffer_status = YY_BUFFER_NEW;
2527
2528         dynC_switch_to_buffer(b  );
2529
2530         return b;
2531 }
2532
2533 /** Setup the input buffer state to scan a string. The next call to dynClex() will
2534  * scan from a @e copy of @a str.
2535  * @param yystr a NUL-terminated string to scan
2536  * 
2537  * @return the newly allocated buffer state object.
2538  * @note If you want to scan bytes that may contain NUL values, then use
2539  *       dynC_scan_bytes() instead.
2540  */
2541 YY_BUFFER_STATE dynC_scan_string (yyconst char * yystr )
2542 {
2543     
2544         return dynC_scan_bytes(yystr,(int) strlen(yystr) );
2545 }
2546
2547 /** Setup the input buffer state to scan the given bytes. The next call to dynClex() will
2548  * scan from a @e copy of @a bytes.
2549  * @param yybytes the byte buffer to scan
2550  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2551  * 
2552  * @return the newly allocated buffer state object.
2553  */
2554 YY_BUFFER_STATE dynC_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2555 {
2556         YY_BUFFER_STATE b;
2557         char *buf;
2558         yy_size_t n;
2559         yy_size_t i;
2560     
2561         /* Get memory for full buffer, including space for trailing EOB's. */
2562         n = (yy_size_t) _yybytes_len + 2;
2563         buf = (char *) dynCalloc(n  );
2564         if ( ! buf )
2565                 YY_FATAL_ERROR( "out of dynamic memory in dynC_scan_bytes()" );
2566
2567         for ( i = 0; i < _yybytes_len; ++i )
2568                 buf[i] = yybytes[i];
2569
2570         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2571
2572         b = dynC_scan_buffer(buf,n );
2573         if ( ! b )
2574                 YY_FATAL_ERROR( "bad buffer in dynC_scan_bytes()" );
2575
2576         /* It's okay to grow etc. this buffer, and we should throw it
2577          * away when we're done.
2578          */
2579         b->yy_is_our_buffer = 1;
2580
2581         return b;
2582 }
2583
2584 #ifndef YY_EXIT_FAILURE
2585 #define YY_EXIT_FAILURE 2
2586 #endif
2587
2588 static void yynoreturn yy_fatal_error (yyconst char* msg )
2589 {
2590                         (void) fprintf( stderr, "%s\n", msg );
2591         exit( YY_EXIT_FAILURE );
2592 }
2593
2594 /* Redefine yyless() so it works in section 3 code. */
2595
2596 #undef yyless
2597 #define yyless(n) \
2598         do \
2599                 { \
2600                 /* Undo effects of setting up dynCtext. */ \
2601         int yyless_macro_arg = (n); \
2602         YY_LESS_LINENO(yyless_macro_arg);\
2603                 dynCtext[dynCleng] = (yy_hold_char); \
2604                 (yy_c_buf_p) = dynCtext + yyless_macro_arg; \
2605                 (yy_hold_char) = *(yy_c_buf_p); \
2606                 *(yy_c_buf_p) = '\0'; \
2607                 dynCleng = yyless_macro_arg; \
2608                 } \
2609         while ( 0 )
2610
2611 /* Accessor  methods (get/set functions) to struct members. */
2612
2613 /** Get the current line number.
2614  * 
2615  */
2616 int dynCget_lineno  (void)
2617 {
2618         
2619     return dynClineno;
2620 }
2621
2622 /** Get the input stream.
2623  * 
2624  */
2625 FILE *dynCget_in  (void)
2626 {
2627         return dynCin;
2628 }
2629
2630 /** Get the output stream.
2631  * 
2632  */
2633 FILE *dynCget_out  (void)
2634 {
2635         return dynCout;
2636 }
2637
2638 /** Get the length of the current token.
2639  * 
2640  */
2641 int dynCget_leng  (void)
2642 {
2643         return dynCleng;
2644 }
2645
2646 /** Get the current token.
2647  * 
2648  */
2649
2650 char *dynCget_text  (void)
2651 {
2652         return dynCtext;
2653 }
2654
2655 /** Set the current line number.
2656  * @param _line_number line number
2657  * 
2658  */
2659 void dynCset_lineno (int  _line_number )
2660 {
2661     
2662     dynClineno = _line_number;
2663 }
2664
2665 /** Set the input stream. This does not discard the current
2666  * input buffer.
2667  * @param _in_str A readable stream.
2668  * 
2669  * @see dynC_switch_to_buffer
2670  */
2671 void dynCset_in (FILE *  _in_str )
2672 {
2673         dynCin = _in_str ;
2674 }
2675
2676 void dynCset_out (FILE *  _out_str )
2677 {
2678         dynCout = _out_str ;
2679 }
2680
2681 int dynCget_debug  (void)
2682 {
2683         return dynC_flex_debug;
2684 }
2685
2686 void dynCset_debug (int  _bdebug )
2687 {
2688         dynC_flex_debug = _bdebug ;
2689 }
2690
2691 static int yy_init_globals (void)
2692 {
2693         /* Initialization is the same as for the non-reentrant scanner.
2694      * This function is called from dynClex_destroy(), so don't allocate here.
2695      */
2696
2697     /* We do not touch dynClineno unless the option is enabled. */
2698     dynClineno =  1;
2699     
2700     (yy_buffer_stack) = NULL;
2701     (yy_buffer_stack_top) = 0;
2702     (yy_buffer_stack_max) = 0;
2703     (yy_c_buf_p) = NULL;
2704     (yy_init) = 0;
2705     (yy_start) = 0;
2706
2707 /* Defined in main.c */
2708 #ifdef YY_STDINIT
2709     dynCin = stdin;
2710     dynCout = stdout;
2711 #else
2712     dynCin = NULL;
2713     dynCout = NULL;
2714 #endif
2715
2716     /* For future reference: Set errno on error, since we are called by
2717      * dynClex_init()
2718      */
2719     return 0;
2720 }
2721
2722 /* dynClex_destroy is for both reentrant and non-reentrant scanners. */
2723 int dynClex_destroy  (void)
2724 {
2725     
2726     /* Pop the buffer stack, destroying each element. */
2727         while(YY_CURRENT_BUFFER){
2728                 dynC_delete_buffer(YY_CURRENT_BUFFER  );
2729                 YY_CURRENT_BUFFER_LVALUE = NULL;
2730                 dynCpop_buffer_state();
2731         }
2732
2733         /* Destroy the stack itself. */
2734         dynCfree((yy_buffer_stack) );
2735         (yy_buffer_stack) = NULL;
2736
2737     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2738      * dynClex() is called, initialization will occur. */
2739     yy_init_globals( );
2740
2741     return 0;
2742 }
2743
2744 /*
2745  * Internal utility routines.
2746  */
2747
2748 #ifndef yytext_ptr
2749 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2750 {
2751
2752         int i;
2753         for ( i = 0; i < n; ++i )
2754                 s1[i] = s2[i];
2755 }
2756 #endif
2757
2758 #ifdef YY_NEED_STRLEN
2759 static int yy_flex_strlen (yyconst char * s )
2760 {
2761         int n;
2762         for ( n = 0; s[n]; ++n )
2763                 ;
2764
2765         return n;
2766 }
2767 #endif
2768
2769 void *dynCalloc (yy_size_t  size )
2770 {
2771                         return malloc(size);
2772 }
2773
2774 void *dynCrealloc  (void * ptr, yy_size_t  size )
2775 {
2776
2777         /* The cast to (char *) in the following accommodates both
2778          * implementations that use char* generic pointers, and those
2779          * that use void* generic pointers.  It works with the latter
2780          * because both ANSI C and C++ allow castless assignment from
2781          * any pointer type to void*, and deal with argument conversions
2782          * as though doing an assignment.
2783          */
2784         return realloc(ptr, size);
2785 }
2786
2787 void dynCfree (void * ptr )
2788 {
2789                         free( (char *) ptr );   /* see dynCrealloc() for (char *) cast */
2790 }
2791
2792 #define YYTABLES_NAME "yytables"
2793
2794 #line 227 "C.l"
2795
2796
2797
2798 void set_lex_input(char *str)
2799 {
2800    static bool firstCall = true;
2801    YY_BUFFER_STATE bp;
2802    
2803    //db removed firstcall check
2804    if(!firstCall) dynC_flush_buffer(YY_CURRENT_BUFFER);
2805    yycolumn = 0;
2806    line_num = 1;
2807    
2808    input_str = str;
2809    bp = dynC_scan_string(str);
2810    (void)bp; // unused warning...
2811    firstCall = false;
2812 }
2813
2814