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