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