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