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