Merge nodehelper lib and example codes into charm
[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
838 /* We return Tokens only when not in a comment. */
839 #define Return if (!in_comment) return
840 #define Token(x) x
841 #define Yval yylval.strval = strcpy(new char[yyleng+1], yytext)
842
843 #ifdef yywrap
844 #undef yywrap
845 #endif
846
847 #line 848 "lex.yy.c"
848
849 #define INITIAL 0
850
851 #ifndef YY_NO_UNISTD_H
852 /* Special case for "unistd.h", since it is non-ANSI. We include it way
853  * down here because we want the user's section 1 to have been scanned first.
854  * The user has a chance to override it with an option.
855  */
856 #include <unistd.h>
857 #endif
858
859 #ifndef YY_EXTRA_TYPE
860 #define YY_EXTRA_TYPE void *
861 #endif
862
863 static int yy_init_globals (void );
864
865 /* Accessor methods to globals.
866    These are made visible to non-reentrant scanners for convenience. */
867
868 int yylex_destroy (void );
869
870 int yyget_debug (void );
871
872 void yyset_debug (int debug_flag  );
873
874 YY_EXTRA_TYPE yyget_extra (void );
875
876 void yyset_extra (YY_EXTRA_TYPE user_defined  );
877
878 FILE *yyget_in (void );
879
880 void yyset_in  (FILE * in_str  );
881
882 FILE *yyget_out (void );
883
884 void yyset_out  (FILE * out_str  );
885
886 int yyget_leng (void );
887
888 char *yyget_text (void );
889
890 int yyget_lineno (void );
891
892 void yyset_lineno (int line_number  );
893
894 /* Macros after this point can all be overridden by user definitions in
895  * section 1.
896  */
897
898 #ifndef YY_SKIP_YYWRAP
899 #ifdef __cplusplus
900 extern "C" int yywrap (void );
901 #else
902 extern int yywrap (void );
903 #endif
904 #endif
905
906     static void yyunput (int c,char *buf_ptr  );
907     
908 #ifndef yytext_ptr
909 static void yy_flex_strncpy (char *,yyconst char *,int );
910 #endif
911
912 #ifdef YY_NEED_STRLEN
913 static int yy_flex_strlen (yyconst char * );
914 #endif
915
916 #ifndef YY_NO_INPUT
917
918 #ifdef __cplusplus
919 static int yyinput (void );
920 #else
921 static int input (void );
922 #endif
923
924 #endif
925
926 /* Amount of stuff to slurp up with each read. */
927 #ifndef YY_READ_BUF_SIZE
928 #ifdef __ia64__
929 /* On IA-64, the buffer size is 16k, not 8k */
930 #define YY_READ_BUF_SIZE 16384
931 #else
932 #define YY_READ_BUF_SIZE 8192
933 #endif /* __ia64__ */
934 #endif
935
936 /* Copy whatever the last rule matched to the standard output. */
937 #ifndef ECHO
938 /* This used to be an fputs(), but since the string might contain NUL's,
939  * we now use fwrite().
940  */
941 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
942 #endif
943
944 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
945  * is returned in "result".
946  */
947 #ifndef YY_INPUT
948 #define YY_INPUT(buf,result,max_size) \
949         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
950                 { \
951                 int c = '*'; \
952                 size_t n; \
953                 for ( n = 0; n < max_size && \
954                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
955                         buf[n] = (char) c; \
956                 if ( c == '\n' ) \
957                         buf[n++] = (char) c; \
958                 if ( c == EOF && ferror( yyin ) ) \
959                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
960                 result = n; \
961                 } \
962         else \
963                 { \
964                 errno=0; \
965                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
966                         { \
967                         if( errno != EINTR) \
968                                 { \
969                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
970                                 break; \
971                                 } \
972                         errno=0; \
973                         clearerr(yyin); \
974                         } \
975                 }\
976 \
977
978 #endif
979
980 /* No semi-colon after return; correct usage is to write "yyterminate();" -
981  * we don't want an extra ';' after the "return" because that will cause
982  * some compilers to complain about unreachable statements.
983  */
984 #ifndef yyterminate
985 #define yyterminate() return YY_NULL
986 #endif
987
988 /* Number of entries by which start-condition stack grows. */
989 #ifndef YY_START_STACK_INCR
990 #define YY_START_STACK_INCR 25
991 #endif
992
993 /* Report a fatal error. */
994 #ifndef YY_FATAL_ERROR
995 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
996 #endif
997
998 /* end tables serialization structures and prototypes */
999
1000 /* Default declaration of generated scanner - a define so the user can
1001  * easily add parameters.
1002  */
1003 #ifndef YY_DECL
1004 #define YY_DECL_IS_OURS 1
1005
1006 extern int yylex (void);
1007
1008 #define YY_DECL int yylex (void)
1009 #endif /* !YY_DECL */
1010
1011 /* Code executed at the beginning of each rule, after yytext and yyleng
1012  * have been set up.
1013  */
1014 #ifndef YY_USER_ACTION
1015 #define YY_USER_ACTION
1016 #endif
1017
1018 /* Code executed at the end of each rule. */
1019 #ifndef YY_BREAK
1020 #define YY_BREAK break;
1021 #endif
1022
1023 #define YY_RULE_SETUP \
1024         YY_USER_ACTION
1025
1026 /** The main scanner function which does all the work.
1027  */
1028 YY_DECL
1029 {
1030         register yy_state_type yy_current_state;
1031         register char *yy_cp, *yy_bp;
1032         register int yy_act;
1033     
1034 #line 57 "xi-scan.l"
1035
1036 #line 1037 "lex.yy.c"
1037
1038         if ( !(yy_init) )
1039                 {
1040                 (yy_init) = 1;
1041
1042 #ifdef YY_USER_INIT
1043                 YY_USER_INIT;
1044 #endif
1045
1046         /* Create the reject buffer large enough to save one state per allowed character. */
1047         if ( ! (yy_state_buf) )
1048             (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
1049             if ( ! (yy_state_buf) )
1050                 YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1051
1052                 if ( ! (yy_start) )
1053                         (yy_start) = 1; /* first start state */
1054
1055                 if ( ! yyin )
1056                         yyin = stdin;
1057
1058                 if ( ! yyout )
1059                         yyout = stdout;
1060
1061                 if ( ! YY_CURRENT_BUFFER ) {
1062                         yyensure_buffer_stack ();
1063                         YY_CURRENT_BUFFER_LVALUE =
1064                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1065                 }
1066
1067                 yy_load_buffer_state( );
1068                 }
1069
1070         while ( 1 )             /* loops until end-of-file is reached */
1071                 {
1072                 yy_cp = (yy_c_buf_p);
1073
1074                 /* Support of yytext. */
1075                 *yy_cp = (yy_hold_char);
1076
1077                 /* yy_bp points to the position in yy_ch_buf of the start of
1078                  * the current run.
1079                  */
1080                 yy_bp = yy_cp;
1081
1082                 yy_current_state = (yy_start);
1083
1084                 (yy_state_ptr) = (yy_state_buf);
1085                 *(yy_state_ptr)++ = yy_current_state;
1086
1087 yy_match:
1088                 do
1089                         {
1090                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1091                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1092                                 {
1093                                 yy_current_state = (int) yy_def[yy_current_state];
1094                                 if ( yy_current_state >= 158 )
1095                                         yy_c = yy_meta[(unsigned int) yy_c];
1096                                 }
1097                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1098                         *(yy_state_ptr)++ = yy_current_state;
1099                         ++yy_cp;
1100                         }
1101                 while ( yy_base[yy_current_state] != 1130 );
1102
1103 yy_find_action:
1104                 yy_current_state = *--(yy_state_ptr);
1105                 (yy_lp) = yy_accept[yy_current_state];
1106 find_rule: /* we branch to this label when backing up */
1107                 for ( ; ; ) /* until we find what rule we matched */
1108                         {
1109                         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
1110                                 {
1111                                 yy_act = yy_acclist[(yy_lp)];
1112                                         {
1113                                         (yy_full_match) = yy_cp;
1114                                         break;
1115                                         }
1116                                 }
1117                         --yy_cp;
1118                         yy_current_state = *--(yy_state_ptr);
1119                         (yy_lp) = yy_accept[yy_current_state];
1120                         }
1121
1122                 YY_DO_BEFORE_ACTION;
1123
1124 do_action:      /* This label is used only to access EOF actions. */
1125
1126                 switch ( yy_act )
1127         { /* beginning of action switch */
1128 case 1:
1129 /* rule 1 can match eol */
1130 YY_RULE_SETUP
1131 #line 58 "xi-scan.l"
1132 { if (in_bracket) {Yval;return Token(CPROGRAM);} else REJECT;}
1133         YY_BREAK
1134 case 2:
1135 /* rule 2 can match eol */
1136 YY_RULE_SETUP
1137 #line 59 "xi-scan.l"
1138 { if (in_braces) {Yval;return Token(CPROGRAM);} else REJECT;}
1139         YY_BREAK
1140 case 3:
1141 /* rule 3 can match eol */
1142 YY_RULE_SETUP
1143 #line 60 "xi-scan.l"
1144 { if (in_int_expr) {Yval;return Token(CPROGRAM);} else REJECT;}
1145         YY_BREAK
1146 case 4:
1147 YY_RULE_SETUP
1148 #line 61 "xi-scan.l"
1149 { /* ignore single line comments */ }
1150         YY_BREAK
1151 case 5:
1152 YY_RULE_SETUP
1153 #line 62 "xi-scan.l"
1154 { /* ignore ^M characters for dos-unix compat */ }
1155         YY_BREAK
1156 case 6:
1157 YY_RULE_SETUP
1158 #line 63 "xi-scan.l"
1159 { in_comment = 1; /* Single line C-style comments */ }
1160         YY_BREAK
1161 case 7:
1162 YY_RULE_SETUP
1163 #line 64 "xi-scan.l"
1164 { in_comment = 0; }
1165         YY_BREAK
1166 case 8:
1167 YY_RULE_SETUP
1168 #line 65 "xi-scan.l"
1169 { Return Token(HASHIF); }
1170         YY_BREAK
1171 case 9:
1172 YY_RULE_SETUP
1173 #line 66 "xi-scan.l"
1174 { Return Token(HASHIFDEF); }
1175         YY_BREAK
1176 case 10:
1177 YY_RULE_SETUP
1178 #line 67 "xi-scan.l"
1179 { in_comment = 0; /* comments */ }
1180         YY_BREAK
1181 case 11:
1182 YY_RULE_SETUP
1183 #line 68 "xi-scan.l"
1184 { /* ignore white space */ }
1185         YY_BREAK
1186 case 12:
1187 /* rule 12 can match eol */
1188 YY_RULE_SETUP
1189 #line 69 "xi-scan.l"
1190 { lineno++;}
1191         YY_BREAK
1192 case 13:
1193 YY_RULE_SETUP
1194 #line 70 "xi-scan.l"
1195 { Yval; Return Token(NUMBER); }
1196         YY_BREAK
1197 case 14:
1198 /* rule 14 can match eol */
1199 YY_RULE_SETUP
1200 #line 71 "xi-scan.l"
1201 { Yval; Return Token(LITERAL); }
1202         YY_BREAK
1203 case 15:
1204 YY_RULE_SETUP
1205 #line 72 "xi-scan.l"
1206 { Return Token(search(yytext)); }
1207         YY_BREAK
1208 case 16:
1209 YY_RULE_SETUP
1210 #line 73 "xi-scan.l"
1211 { Return Token(yytext[0]); }
1212         YY_BREAK
1213 case 17:
1214 YY_RULE_SETUP
1215 #line 74 "xi-scan.l"
1216 ECHO;
1217         YY_BREAK
1218 #line 1219 "lex.yy.c"
1219                         case YY_STATE_EOF(INITIAL):
1220                                 yyterminate();
1221
1222         case YY_END_OF_BUFFER:
1223                 {
1224                 /* Amount of text matched not including the EOB char. */
1225                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1226
1227                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1228                 *yy_cp = (yy_hold_char);
1229                 YY_RESTORE_YY_MORE_OFFSET
1230
1231                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1232                         {
1233                         /* We're scanning a new file or input source.  It's
1234                          * possible that this happened because the user
1235                          * just pointed yyin at a new source and called
1236                          * yylex().  If so, then we have to assure
1237                          * consistency between YY_CURRENT_BUFFER and our
1238                          * globals.  Here is the right place to do so, because
1239                          * this is the first action (other than possibly a
1240                          * back-up) that will match for the new input source.
1241                          */
1242                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1243                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1244                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1245                         }
1246
1247                 /* Note that here we test for yy_c_buf_p "<=" to the position
1248                  * of the first EOB in the buffer, since yy_c_buf_p will
1249                  * already have been incremented past the NUL character
1250                  * (since all states make transitions on EOB to the
1251                  * end-of-buffer state).  Contrast this with the test
1252                  * in input().
1253                  */
1254                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1255                         { /* This was really a NUL. */
1256                         yy_state_type yy_next_state;
1257
1258                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1259
1260                         yy_current_state = yy_get_previous_state(  );
1261
1262                         /* Okay, we're now positioned to make the NUL
1263                          * transition.  We couldn't have
1264                          * yy_get_previous_state() go ahead and do it
1265                          * for us because it doesn't know how to deal
1266                          * with the possibility of jamming (and we don't
1267                          * want to build jamming into it because then it
1268                          * will run more slowly).
1269                          */
1270
1271                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1272
1273                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1274
1275                         if ( yy_next_state )
1276                                 {
1277                                 /* Consume the NUL. */
1278                                 yy_cp = ++(yy_c_buf_p);
1279                                 yy_current_state = yy_next_state;
1280                                 goto yy_match;
1281                                 }
1282
1283                         else
1284                                 {
1285                                 yy_cp = (yy_c_buf_p);
1286                                 goto yy_find_action;
1287                                 }
1288                         }
1289
1290                 else switch ( yy_get_next_buffer(  ) )
1291                         {
1292                         case EOB_ACT_END_OF_FILE:
1293                                 {
1294                                 (yy_did_buffer_switch_on_eof) = 0;
1295
1296                                 if ( yywrap( ) )
1297                                         {
1298                                         /* Note: because we've taken care in
1299                                          * yy_get_next_buffer() to have set up
1300                                          * yytext, we can now set up
1301                                          * yy_c_buf_p so that if some total
1302                                          * hoser (like flex itself) wants to
1303                                          * call the scanner after we return the
1304                                          * YY_NULL, it'll still work - another
1305                                          * YY_NULL will get returned.
1306                                          */
1307                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1308
1309                                         yy_act = YY_STATE_EOF(YY_START);
1310                                         goto do_action;
1311                                         }
1312
1313                                 else
1314                                         {
1315                                         if ( ! (yy_did_buffer_switch_on_eof) )
1316                                                 YY_NEW_FILE;
1317                                         }
1318                                 break;
1319                                 }
1320
1321                         case EOB_ACT_CONTINUE_SCAN:
1322                                 (yy_c_buf_p) =
1323                                         (yytext_ptr) + yy_amount_of_matched_text;
1324
1325                                 yy_current_state = yy_get_previous_state(  );
1326
1327                                 yy_cp = (yy_c_buf_p);
1328                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1329                                 goto yy_match;
1330
1331                         case EOB_ACT_LAST_MATCH:
1332                                 (yy_c_buf_p) =
1333                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1334
1335                                 yy_current_state = yy_get_previous_state(  );
1336
1337                                 yy_cp = (yy_c_buf_p);
1338                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1339                                 goto yy_find_action;
1340                         }
1341                 break;
1342                 }
1343
1344         default:
1345                 YY_FATAL_ERROR(
1346                         "fatal flex scanner internal error--no action found" );
1347         } /* end of action switch */
1348                 } /* end of scanning one token */
1349 } /* end of yylex */
1350
1351 /* yy_get_next_buffer - try to read in a new buffer
1352  *
1353  * Returns a code representing an action:
1354  *      EOB_ACT_LAST_MATCH -
1355  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1356  *      EOB_ACT_END_OF_FILE - end of file
1357  */
1358 static int yy_get_next_buffer (void)
1359 {
1360         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1361         register char *source = (yytext_ptr);
1362         register int number_to_move, i;
1363         int ret_val;
1364
1365         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1366                 YY_FATAL_ERROR(
1367                 "fatal flex scanner internal error--end of buffer missed" );
1368
1369         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1370                 { /* Don't try to fill the buffer, so this is an EOF. */
1371                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1372                         {
1373                         /* We matched a single character, the EOB, so
1374                          * treat this as a final EOF.
1375                          */
1376                         return EOB_ACT_END_OF_FILE;
1377                         }
1378
1379                 else
1380                         {
1381                         /* We matched some text prior to the EOB, first
1382                          * process it.
1383                          */
1384                         return EOB_ACT_LAST_MATCH;
1385                         }
1386                 }
1387
1388         /* Try to read more data. */
1389
1390         /* First move last chars to start of buffer. */
1391         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1392
1393         for ( i = 0; i < number_to_move; ++i )
1394                 *(dest++) = *(source++);
1395
1396         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1397                 /* don't do the read, it's not guaranteed to return an EOF,
1398                  * just force an EOF
1399                  */
1400                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1401
1402         else
1403                 {
1404                         int num_to_read =
1405                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1406
1407                 while ( num_to_read <= 0 )
1408                         { /* Not enough room in the buffer - grow it. */
1409
1410                         YY_FATAL_ERROR(
1411 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1412
1413                         }
1414
1415                 if ( num_to_read > YY_READ_BUF_SIZE )
1416                         num_to_read = YY_READ_BUF_SIZE;
1417
1418                 /* Read in more data. */
1419                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1420                         (yy_n_chars), (size_t) num_to_read );
1421
1422                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1423                 }
1424
1425         if ( (yy_n_chars) == 0 )
1426                 {
1427                 if ( number_to_move == YY_MORE_ADJ )
1428                         {
1429                         ret_val = EOB_ACT_END_OF_FILE;
1430                         yyrestart(yyin  );
1431                         }
1432
1433                 else
1434                         {
1435                         ret_val = EOB_ACT_LAST_MATCH;
1436                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1437                                 YY_BUFFER_EOF_PENDING;
1438                         }
1439                 }
1440
1441         else
1442                 ret_val = EOB_ACT_CONTINUE_SCAN;
1443
1444         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1445                 /* Extend the array by 50%, plus the number we really need. */
1446                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1447                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1448                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1449                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1450         }
1451
1452         (yy_n_chars) += number_to_move;
1453         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1454         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1455
1456         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1457
1458         return ret_val;
1459 }
1460
1461 /* yy_get_previous_state - get the state just before the EOB char was reached */
1462
1463     static yy_state_type yy_get_previous_state (void)
1464 {
1465         register yy_state_type yy_current_state;
1466         register char *yy_cp;
1467     
1468         yy_current_state = (yy_start);
1469
1470         (yy_state_ptr) = (yy_state_buf);
1471         *(yy_state_ptr)++ = yy_current_state;
1472
1473         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1474                 {
1475                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1476                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1477                         {
1478                         yy_current_state = (int) yy_def[yy_current_state];
1479                         if ( yy_current_state >= 158 )
1480                                 yy_c = yy_meta[(unsigned int) yy_c];
1481                         }
1482                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1483                 *(yy_state_ptr)++ = yy_current_state;
1484                 }
1485
1486         return yy_current_state;
1487 }
1488
1489 /* yy_try_NUL_trans - try to make a transition on the NUL character
1490  *
1491  * synopsis
1492  *      next_state = yy_try_NUL_trans( current_state );
1493  */
1494     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1495 {
1496         register int yy_is_jam;
1497     
1498         register YY_CHAR yy_c = 1;
1499         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1500                 {
1501                 yy_current_state = (int) yy_def[yy_current_state];
1502                 if ( yy_current_state >= 158 )
1503                         yy_c = yy_meta[(unsigned int) yy_c];
1504                 }
1505         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1506         yy_is_jam = (yy_current_state == 157);
1507         if ( ! yy_is_jam )
1508                 *(yy_state_ptr)++ = yy_current_state;
1509
1510         return yy_is_jam ? 0 : yy_current_state;
1511 }
1512
1513     static void yyunput (int c, register char * yy_bp )
1514 {
1515         register char *yy_cp;
1516     
1517     yy_cp = (yy_c_buf_p);
1518
1519         /* undo effects of setting up yytext */
1520         *yy_cp = (yy_hold_char);
1521
1522         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1523                 { /* need to shift things up to make room */
1524                 /* +2 for EOB chars. */
1525                 register int number_to_move = (yy_n_chars) + 2;
1526                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1527                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1528                 register char *source =
1529                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1530
1531                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1532                         *--dest = *--source;
1533
1534                 yy_cp += (int) (dest - source);
1535                 yy_bp += (int) (dest - source);
1536                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1537                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1538
1539                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1540                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1541                 }
1542
1543         *--yy_cp = (char) c;
1544
1545         (yytext_ptr) = yy_bp;
1546         (yy_hold_char) = *yy_cp;
1547         (yy_c_buf_p) = yy_cp;
1548 }
1549
1550 #ifndef YY_NO_INPUT
1551 #ifdef __cplusplus
1552     static int yyinput (void)
1553 #else
1554     static int input  (void)
1555 #endif
1556
1557 {
1558         int c;
1559     
1560         *(yy_c_buf_p) = (yy_hold_char);
1561
1562         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1563                 {
1564                 /* yy_c_buf_p now points to the character we want to return.
1565                  * If this occurs *before* the EOB characters, then it's a
1566                  * valid NUL; if not, then we've hit the end of the buffer.
1567                  */
1568                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1569                         /* This was really a NUL. */
1570                         *(yy_c_buf_p) = '\0';
1571
1572                 else
1573                         { /* need more input */
1574                         int offset = (yy_c_buf_p) - (yytext_ptr);
1575                         ++(yy_c_buf_p);
1576
1577                         switch ( yy_get_next_buffer(  ) )
1578                                 {
1579                                 case EOB_ACT_LAST_MATCH:
1580                                         /* This happens because yy_g_n_b()
1581                                          * sees that we've accumulated a
1582                                          * token and flags that we need to
1583                                          * try matching the token before
1584                                          * proceeding.  But for input(),
1585                                          * there's no matching to consider.
1586                                          * So convert the EOB_ACT_LAST_MATCH
1587                                          * to EOB_ACT_END_OF_FILE.
1588                                          */
1589
1590                                         /* Reset buffer status. */
1591                                         yyrestart(yyin );
1592
1593                                         /*FALLTHROUGH*/
1594
1595                                 case EOB_ACT_END_OF_FILE:
1596                                         {
1597                                         if ( yywrap( ) )
1598                                                 return EOF;
1599
1600                                         if ( ! (yy_did_buffer_switch_on_eof) )
1601                                                 YY_NEW_FILE;
1602 #ifdef __cplusplus
1603                                         return yyinput();
1604 #else
1605                                         return input();
1606 #endif
1607                                         }
1608
1609                                 case EOB_ACT_CONTINUE_SCAN:
1610                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1611                                         break;
1612                                 }
1613                         }
1614                 }
1615
1616         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1617         *(yy_c_buf_p) = '\0';   /* preserve yytext */
1618         (yy_hold_char) = *++(yy_c_buf_p);
1619
1620         return c;
1621 }
1622 #endif  /* ifndef YY_NO_INPUT */
1623
1624 /** Immediately switch to a different input stream.
1625  * @param input_file A readable stream.
1626  * 
1627  * @note This function does not reset the start condition to @c INITIAL .
1628  */
1629     void yyrestart  (FILE * input_file )
1630 {
1631     
1632         if ( ! YY_CURRENT_BUFFER ){
1633         yyensure_buffer_stack ();
1634                 YY_CURRENT_BUFFER_LVALUE =
1635             yy_create_buffer(yyin,YY_BUF_SIZE );
1636         }
1637
1638         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1639         yy_load_buffer_state( );
1640 }
1641
1642 /** Switch to a different input buffer.
1643  * @param new_buffer The new input buffer.
1644  * 
1645  */
1646     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1647 {
1648     
1649         /* TODO. We should be able to replace this entire function body
1650          * with
1651          *              yypop_buffer_state();
1652          *              yypush_buffer_state(new_buffer);
1653      */
1654         yyensure_buffer_stack ();
1655         if ( YY_CURRENT_BUFFER == new_buffer )
1656                 return;
1657
1658         if ( YY_CURRENT_BUFFER )
1659                 {
1660                 /* Flush out information for old buffer. */
1661                 *(yy_c_buf_p) = (yy_hold_char);
1662                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1663                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1664                 }
1665
1666         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1667         yy_load_buffer_state( );
1668
1669         /* We don't actually know whether we did this switch during
1670          * EOF (yywrap()) processing, but the only time this flag
1671          * is looked at is after yywrap() is called, so it's safe
1672          * to go ahead and always set it.
1673          */
1674         (yy_did_buffer_switch_on_eof) = 1;
1675 }
1676
1677 static void yy_load_buffer_state  (void)
1678 {
1679         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1680         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1681         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1682         (yy_hold_char) = *(yy_c_buf_p);
1683 }
1684
1685 /** Allocate and initialize an input buffer state.
1686  * @param file A readable stream.
1687  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1688  * 
1689  * @return the allocated buffer state.
1690  */
1691     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1692 {
1693         YY_BUFFER_STATE b;
1694     
1695         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1696         if ( ! b )
1697                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1698
1699         b->yy_buf_size = size;
1700
1701         /* yy_ch_buf has to be 2 characters longer than the size given because
1702          * we need to put in 2 end-of-buffer characters.
1703          */
1704         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1705         if ( ! b->yy_ch_buf )
1706                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1707
1708         b->yy_is_our_buffer = 1;
1709
1710         yy_init_buffer(b,file );
1711
1712         return b;
1713 }
1714
1715 /** Destroy the buffer.
1716  * @param b a buffer created with yy_create_buffer()
1717  * 
1718  */
1719     void yy_delete_buffer (YY_BUFFER_STATE  b )
1720 {
1721     
1722         if ( ! b )
1723                 return;
1724
1725         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1726                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1727
1728         if ( b->yy_is_our_buffer )
1729                 yyfree((void *) b->yy_ch_buf  );
1730
1731         yyfree((void *) b  );
1732 }
1733
1734 #ifndef __cplusplus
1735 extern int isatty (int );
1736 #endif /* __cplusplus */
1737     
1738 /* Initializes or reinitializes a buffer.
1739  * This function is sometimes called more than once on the same buffer,
1740  * such as during a yyrestart() or at EOF.
1741  */
1742     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1743
1744 {
1745         int oerrno = errno;
1746     
1747         yy_flush_buffer(b );
1748
1749         b->yy_input_file = file;
1750         b->yy_fill_buffer = 1;
1751
1752     /* If b is the current buffer, then yy_init_buffer was _probably_
1753      * called from yyrestart() or through yy_get_next_buffer.
1754      * In that case, we don't want to reset the lineno or column.
1755      */
1756     if (b != YY_CURRENT_BUFFER){
1757         b->yy_bs_lineno = 1;
1758         b->yy_bs_column = 0;
1759     }
1760
1761         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1762     
1763         errno = oerrno;
1764 }
1765
1766 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1767  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1768  * 
1769  */
1770     void yy_flush_buffer (YY_BUFFER_STATE  b )
1771 {
1772         if ( ! b )
1773                 return;
1774
1775         b->yy_n_chars = 0;
1776
1777         /* We always need two end-of-buffer characters.  The first causes
1778          * a transition to the end-of-buffer state.  The second causes
1779          * a jam in that state.
1780          */
1781         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1782         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1783
1784         b->yy_buf_pos = &b->yy_ch_buf[0];
1785
1786         b->yy_at_bol = 1;
1787         b->yy_buffer_status = YY_BUFFER_NEW;
1788
1789         if ( b == YY_CURRENT_BUFFER )
1790                 yy_load_buffer_state( );
1791 }
1792
1793 /** Pushes the new state onto the stack. The new state becomes
1794  *  the current state. This function will allocate the stack
1795  *  if necessary.
1796  *  @param new_buffer The new state.
1797  *  
1798  */
1799 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1800 {
1801         if (new_buffer == NULL)
1802                 return;
1803
1804         yyensure_buffer_stack();
1805
1806         /* This block is copied from yy_switch_to_buffer. */
1807         if ( YY_CURRENT_BUFFER )
1808                 {
1809                 /* Flush out information for old buffer. */
1810                 *(yy_c_buf_p) = (yy_hold_char);
1811                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1812                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1813                 }
1814
1815         /* Only push if top exists. Otherwise, replace top. */
1816         if (YY_CURRENT_BUFFER)
1817                 (yy_buffer_stack_top)++;
1818         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1819
1820         /* copied from yy_switch_to_buffer. */
1821         yy_load_buffer_state( );
1822         (yy_did_buffer_switch_on_eof) = 1;
1823 }
1824
1825 /** Removes and deletes the top of the stack, if present.
1826  *  The next element becomes the new top.
1827  *  
1828  */
1829 void yypop_buffer_state (void)
1830 {
1831         if (!YY_CURRENT_BUFFER)
1832                 return;
1833
1834         yy_delete_buffer(YY_CURRENT_BUFFER );
1835         YY_CURRENT_BUFFER_LVALUE = NULL;
1836         if ((yy_buffer_stack_top) > 0)
1837                 --(yy_buffer_stack_top);
1838
1839         if (YY_CURRENT_BUFFER) {
1840                 yy_load_buffer_state( );
1841                 (yy_did_buffer_switch_on_eof) = 1;
1842         }
1843 }
1844
1845 /* Allocates the stack if it does not exist.
1846  *  Guarantees space for at least one push.
1847  */
1848 static void yyensure_buffer_stack (void)
1849 {
1850         int num_to_alloc;
1851     
1852         if (!(yy_buffer_stack)) {
1853
1854                 /* First allocation is just for 2 elements, since we don't know if this
1855                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1856                  * immediate realloc on the next call.
1857          */
1858                 num_to_alloc = 1;
1859                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1860                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1861                                                                 );
1862                 if ( ! (yy_buffer_stack) )
1863                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1864                                                                   
1865                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1866                                 
1867                 (yy_buffer_stack_max) = num_to_alloc;
1868                 (yy_buffer_stack_top) = 0;
1869                 return;
1870         }
1871
1872         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1873
1874                 /* Increase the buffer to prepare for a possible push. */
1875                 int grow_size = 8 /* arbitrary grow size */;
1876
1877                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1878                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1879                                                                 ((yy_buffer_stack),
1880                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1881                                                                 );
1882                 if ( ! (yy_buffer_stack) )
1883                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1884
1885                 /* zero only the new slots.*/
1886                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1887                 (yy_buffer_stack_max) = num_to_alloc;
1888         }
1889 }
1890
1891 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1892  * @param base the character buffer
1893  * @param size the size in bytes of the character buffer
1894  * 
1895  * @return the newly allocated buffer state object. 
1896  */
1897 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
1898 {
1899         YY_BUFFER_STATE b;
1900     
1901         if ( size < 2 ||
1902              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1903              base[size-1] != YY_END_OF_BUFFER_CHAR )
1904                 /* They forgot to leave room for the EOB's. */
1905                 return 0;
1906
1907         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1908         if ( ! b )
1909                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1910
1911         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1912         b->yy_buf_pos = b->yy_ch_buf = base;
1913         b->yy_is_our_buffer = 0;
1914         b->yy_input_file = 0;
1915         b->yy_n_chars = b->yy_buf_size;
1916         b->yy_is_interactive = 0;
1917         b->yy_at_bol = 1;
1918         b->yy_fill_buffer = 0;
1919         b->yy_buffer_status = YY_BUFFER_NEW;
1920
1921         yy_switch_to_buffer(b  );
1922
1923         return b;
1924 }
1925
1926 /** Setup the input buffer state to scan a string. The next call to yylex() will
1927  * scan from a @e copy of @a str.
1928  * @param yystr a NUL-terminated string to scan
1929  * 
1930  * @return the newly allocated buffer state object.
1931  * @note If you want to scan bytes that may contain NUL values, then use
1932  *       yy_scan_bytes() instead.
1933  */
1934 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1935 {
1936     
1937         return yy_scan_bytes(yystr,strlen(yystr) );
1938 }
1939
1940 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1941  * scan from a @e copy of @a bytes.
1942  * @param yybytes the byte buffer to scan
1943  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1944  * 
1945  * @return the newly allocated buffer state object.
1946  */
1947 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1948 {
1949         YY_BUFFER_STATE b;
1950         char *buf;
1951         yy_size_t n;
1952         int i;
1953     
1954         /* Get memory for full buffer, including space for trailing EOB's. */
1955         n = _yybytes_len + 2;
1956         buf = (char *) yyalloc(n  );
1957         if ( ! buf )
1958                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1959
1960         for ( i = 0; i < _yybytes_len; ++i )
1961                 buf[i] = yybytes[i];
1962
1963         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1964
1965         b = yy_scan_buffer(buf,n );
1966         if ( ! b )
1967                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1968
1969         /* It's okay to grow etc. this buffer, and we should throw it
1970          * away when we're done.
1971          */
1972         b->yy_is_our_buffer = 1;
1973
1974         return b;
1975 }
1976
1977 #ifndef YY_EXIT_FAILURE
1978 #define YY_EXIT_FAILURE 2
1979 #endif
1980
1981 static void yy_fatal_error (yyconst char* msg )
1982 {
1983         (void) fprintf( stderr, "%s\n", msg );
1984         exit( YY_EXIT_FAILURE );
1985 }
1986
1987 /* Redefine yyless() so it works in section 3 code. */
1988
1989 #undef yyless
1990 #define yyless(n) \
1991         do \
1992                 { \
1993                 /* Undo effects of setting up yytext. */ \
1994         int yyless_macro_arg = (n); \
1995         YY_LESS_LINENO(yyless_macro_arg);\
1996                 yytext[yyleng] = (yy_hold_char); \
1997                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1998                 (yy_hold_char) = *(yy_c_buf_p); \
1999                 *(yy_c_buf_p) = '\0'; \
2000                 yyleng = yyless_macro_arg; \
2001                 } \
2002         while ( 0 )
2003
2004 /* Accessor  methods (get/set functions) to struct members. */
2005
2006 /** Get the current line number.
2007  * 
2008  */
2009 int yyget_lineno  (void)
2010 {
2011         
2012     return yylineno;
2013 }
2014
2015 /** Get the input stream.
2016  * 
2017  */
2018 FILE *yyget_in  (void)
2019 {
2020         return yyin;
2021 }
2022
2023 /** Get the output stream.
2024  * 
2025  */
2026 FILE *yyget_out  (void)
2027 {
2028         return yyout;
2029 }
2030
2031 /** Get the length of the current token.
2032  * 
2033  */
2034 int yyget_leng  (void)
2035 {
2036         return yyleng;
2037 }
2038
2039 /** Get the current token.
2040  * 
2041  */
2042
2043 char *yyget_text  (void)
2044 {
2045         return yytext;
2046 }
2047
2048 /** Set the current line number.
2049  * @param line_number
2050  * 
2051  */
2052 void yyset_lineno (int  line_number )
2053 {
2054     
2055     yylineno = line_number;
2056 }
2057
2058 /** Set the input stream. This does not discard the current
2059  * input buffer.
2060  * @param in_str A readable stream.
2061  * 
2062  * @see yy_switch_to_buffer
2063  */
2064 void yyset_in (FILE *  in_str )
2065 {
2066         yyin = in_str ;
2067 }
2068
2069 void yyset_out (FILE *  out_str )
2070 {
2071         yyout = out_str ;
2072 }
2073
2074 int yyget_debug  (void)
2075 {
2076         return yy_flex_debug;
2077 }
2078
2079 void yyset_debug (int  bdebug )
2080 {
2081         yy_flex_debug = bdebug ;
2082 }
2083
2084 static int yy_init_globals (void)
2085 {
2086         /* Initialization is the same as for the non-reentrant scanner.
2087      * This function is called from yylex_destroy(), so don't allocate here.
2088      */
2089
2090     (yy_buffer_stack) = 0;
2091     (yy_buffer_stack_top) = 0;
2092     (yy_buffer_stack_max) = 0;
2093     (yy_c_buf_p) = (char *) 0;
2094     (yy_init) = 0;
2095     (yy_start) = 0;
2096
2097     (yy_state_buf) = 0;
2098     (yy_state_ptr) = 0;
2099     (yy_full_match) = 0;
2100     (yy_lp) = 0;
2101
2102 /* Defined in main.c */
2103 #ifdef YY_STDINIT
2104     yyin = stdin;
2105     yyout = stdout;
2106 #else
2107     yyin = (FILE *) 0;
2108     yyout = (FILE *) 0;
2109 #endif
2110
2111     /* For future reference: Set errno on error, since we are called by
2112      * yylex_init()
2113      */
2114     return 0;
2115 }
2116
2117 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2118 int yylex_destroy  (void)
2119 {
2120     
2121     /* Pop the buffer stack, destroying each element. */
2122         while(YY_CURRENT_BUFFER){
2123                 yy_delete_buffer(YY_CURRENT_BUFFER  );
2124                 YY_CURRENT_BUFFER_LVALUE = NULL;
2125                 yypop_buffer_state();
2126         }
2127
2128         /* Destroy the stack itself. */
2129         yyfree((yy_buffer_stack) );
2130         (yy_buffer_stack) = NULL;
2131
2132     yyfree ( (yy_state_buf) );
2133     (yy_state_buf)  = NULL;
2134
2135     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2136      * yylex() is called, initialization will occur. */
2137     yy_init_globals( );
2138
2139     return 0;
2140 }
2141
2142 /*
2143  * Internal utility routines.
2144  */
2145
2146 #ifndef yytext_ptr
2147 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2148 {
2149         register int i;
2150         for ( i = 0; i < n; ++i )
2151                 s1[i] = s2[i];
2152 }
2153 #endif
2154
2155 #ifdef YY_NEED_STRLEN
2156 static int yy_flex_strlen (yyconst char * s )
2157 {
2158         register int n;
2159         for ( n = 0; s[n]; ++n )
2160                 ;
2161
2162         return n;
2163 }
2164 #endif
2165
2166 void *yyalloc (yy_size_t  size )
2167 {
2168         return (void *) malloc( size );
2169 }
2170
2171 void *yyrealloc  (void * ptr, yy_size_t  size )
2172 {
2173         /* The cast to (char *) in the following accommodates both
2174          * implementations that use char* generic pointers, and those
2175          * that use void* generic pointers.  It works with the latter
2176          * because both ANSI C and C++ allow castless assignment from
2177          * any pointer type to void*, and deal with argument conversions
2178          * as though doing an assignment.
2179          */
2180         return (void *) realloc( (char *) ptr, size );
2181 }
2182
2183 void yyfree (void * ptr )
2184 {
2185         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2186 }
2187
2188 #define YYTABLES_NAME "yytables"
2189
2190 #line 74 "xi-scan.l"
2191
2192
2193
2194 struct rwtable {
2195   const char *res;      int tok;
2196 };
2197
2198 /* Reserved word table */
2199 struct rwtable rwtable[] = {
2200 {  "module",    MODULE },
2201 {  "mainmodule",        MAINMODULE },
2202 {  "chare",     CHARE },
2203 {  "group",     GROUP },
2204 {  "nodegroup",  NODEGROUP },
2205 {  "array",     ARRAY },
2206 {  "message",   MESSAGE },
2207 {  "conditional",CONDITIONAL },
2208 {  "extern",    EXTERN },
2209 {  "initcall",  INITCALL },
2210 {  "initnode",  INITNODE },
2211 {  "initproc",  INITPROC },
2212 {  "readonly",  READONLY },
2213 {  "stacksize", STACKSIZE },
2214 {  "threaded",  THREADED },
2215 {  "migratable",        MIGRATABLE },
2216 {  "PUPable",   PUPABLE },
2217 {  "pupable",   PUPABLE },
2218 {  "createhere",        CREATEHERE },
2219 {  "createhome",        CREATEHOME },
2220 {  "nokeep",    NOKEEP },
2221 {  "notrace",   NOTRACE },
2222 {  "template",  TEMPLATE },
2223 {  "class",     CLASS },
2224 {  "include",   INCLUDE },
2225 {  "sync",      SYNC },
2226 {  "iget",       IGET },
2227 {  "exclusive", EXCLUSIVE },
2228 {  "immediate",  IMMEDIATE },
2229 {  "expedited",  SKIPSCHED },
2230 {  "inline",    INLINE },
2231 {  "local",      LOCAL },
2232 {  "virtual",    VIRTUAL },
2233 {  "mainchare", MAINCHARE },
2234 {  "packed",     PACKED },
2235 {  "varsize",    VARSIZE },
2236 {  "entry",      ENTRY },
2237 {  "int",        INT },
2238 {  "short",      SHORT },
2239 {  "long",       LONG },
2240 {  "char",       CHAR },
2241 {  "float",      FLOAT },
2242 {  "double",     DOUBLE },
2243 {  "unsigned",   UNSIGNED },
2244 {  "void",      VOID },
2245 {  "const",     CONST },
2246 {  "atomic",    ATOMIC },
2247 {  "forward",   FORWARD },
2248 {  "when",      WHEN },
2249 {  "while",     WHILE },
2250 {  "for",       FOR },
2251 {  "forall",    FORALL },
2252 {  "if",        IF },
2253 {  "else",      ELSE },
2254 {  "overlap",   OVERLAP },
2255 {  "connect",    CONNECT },
2256 {  "publishes",  PUBLISHES },
2257 {  "python",     PYTHON },
2258 {  "namespace",  NAMESPACE },
2259 {  "using",      USING },
2260 {  "accel",      ACCEL },
2261 {  "readwrite",  READWRITE },
2262 {  "writeonly",  WRITEONLY },
2263 {  "accelblock", ACCELBLOCK },
2264 {  "memcritical", MEMCRITICAL },
2265 {  "reductiontarget", REDUCTIONTARGET },
2266 {  "",          0 }
2267 };
2268
2269 int search(char *s)
2270 {
2271   int i;
2272   for(i=0; rwtable[i].tok != 0; i++) {
2273     if(strcmp(rwtable[i].res, s) == 0)
2274       return(rwtable[i].tok);
2275   }
2276   yylval.strval = strcpy(new char[yyleng+1], s);
2277   return IDENT;
2278 }
2279
2280 int yywrap() { return 1; }
2281