Initial revision
[charm.git] / src / xlat++ / xp-lexer.c
1 /* A lexical scanner generated by flex */
2
3 /* Scanner skeleton version:
4  * $Header$
5  */
6
7 #define FLEX_SCANNER
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
10
11 #include <stdio.h>
12
13
14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
15 #ifdef c_plusplus
16 #ifndef __cplusplus
17 #define __cplusplus
18 #endif
19 #endif
20
21
22 #ifdef __cplusplus
23
24 #include <stdlib.h>
25 #include <unistd.h>
26
27 /* Use prototypes in function declarations. */
28 #define YY_USE_PROTOS
29
30 /* The "const" storage-class-modifier is valid. */
31 #define YY_USE_CONST
32
33 #else   /* ! __cplusplus */
34
35 #if __STDC__
36
37 #define YY_USE_PROTOS
38 #define YY_USE_CONST
39
40 #endif  /* __STDC__ */
41 #endif  /* ! __cplusplus */
42
43 #ifdef __TURBOC__
44  #pragma warn -rch
45  #pragma warn -use
46 #include <io.h>
47 #include <stdlib.h>
48 #define YY_USE_CONST
49 #define YY_USE_PROTOS
50 #endif
51
52 #ifdef YY_USE_CONST
53 #define yyconst const
54 #else
55 #define yyconst
56 #endif
57
58
59 #ifdef YY_USE_PROTOS
60 #define YY_PROTO(proto) proto
61 #else
62 #define YY_PROTO(proto) ()
63 #endif
64
65 /* Returned upon end-of-file. */
66 #define YY_NULL 0
67
68 /* Promotes a possibly negative, possibly signed char to an unsigned
69  * integer for use as an array index.  If the signed char is negative,
70  * we want to instead treat it as an 8-bit unsigned char, hence the
71  * double cast.
72  */
73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
74
75 /* Enter a start condition.  This macro really ought to take a parameter,
76  * but we do it the disgusting crufty way forced on us by the ()-less
77  * definition of BEGIN.
78  */
79 #define BEGIN yy_start = 1 + 2 *
80
81 /* Translate the current start state into a value that can be later handed
82  * to BEGIN to return to the state.  The YYSTATE alias is for lex
83  * compatibility.
84  */
85 #define YY_START ((yy_start - 1) / 2)
86 #define YYSTATE YY_START
87
88 /* Action number for EOF rule of a given start state. */
89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
90
91 /* Special action meaning "start processing a new file". */
92 #define YY_NEW_FILE yyrestart( yyin )
93
94 #define YY_END_OF_BUFFER_CHAR 0
95
96 /* Size of default input buffer. */
97 #define YY_BUF_SIZE 16384
98
99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
100
101 extern int yyleng;
102 extern FILE *yyin, *yyout;
103
104 #define EOB_ACT_CONTINUE_SCAN 0
105 #define EOB_ACT_END_OF_FILE 1
106 #define EOB_ACT_LAST_MATCH 2
107
108 /* The funky do-while in the following #define is used to turn the definition
109  * int a single C statement (which needs a semi-colon terminator).  This
110  * avoids problems with code like:
111  *
112  *      if ( condition_holds )
113  *              yyless( 5 );
114  *      else
115  *              do_something_else();
116  *
117  * Prior to using the do-while the compiler would get upset at the
118  * "else" because it interpreted the "if" statement as being all
119  * done when it reached the ';' after the yyless() call.
120  */
121
122 /* Return all but the first 'n' matched characters back to the input stream. */
123
124 #define yyless(n) \
125         do \
126                 { \
127                 /* Undo effects of setting up yytext. */ \
128                 *yy_cp = yy_hold_char; \
129                 YY_RESTORE_YY_MORE_OFFSET \
130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
131                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
132                 } \
133         while ( 0 )
134
135 #define unput(c) yyunput( c, yytext_ptr )
136
137 /* The following is because we cannot portably get our hands on size_t
138  * (without autoconf's help, which isn't available because we want
139  * flex-generated scanners to compile on their own).
140  */
141 typedef unsigned int yy_size_t;
142
143
144 struct yy_buffer_state
145         {
146         FILE *yy_input_file;
147
148         char *yy_ch_buf;                /* input buffer */
149         char *yy_buf_pos;               /* current position in input buffer */
150
151         /* Size of input buffer in bytes, not including room for EOB
152          * characters.
153          */
154         yy_size_t yy_buf_size;
155
156         /* Number of characters read into yy_ch_buf, not including EOB
157          * characters.
158          */
159         int yy_n_chars;
160
161         /* Whether we "own" the buffer - i.e., we know we created it,
162          * and can realloc() it to grow it, and should free() it to
163          * delete it.
164          */
165         int yy_is_our_buffer;
166
167         /* Whether this is an "interactive" input source; if so, and
168          * if we're using stdio for input, then we want to use getc()
169          * instead of fread(), to make sure we stop fetching input after
170          * each newline.
171          */
172         int yy_is_interactive;
173
174         /* Whether we're considered to be at the beginning of a line.
175          * If so, '^' rules will be active on the next match, otherwise
176          * not.
177          */
178         int yy_at_bol;
179
180         /* Whether to try to fill the input buffer when we reach the
181          * end of it.
182          */
183         int yy_fill_buffer;
184
185         int yy_buffer_status;
186 #define YY_BUFFER_NEW 0
187 #define YY_BUFFER_NORMAL 1
188         /* When an EOF's been seen but there's still some text to process
189          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
190          * shouldn't try reading from the input source any more.  We might
191          * still have a bunch of tokens to match, though, because of
192          * possible backing-up.
193          *
194          * When we actually see the EOF, we change the status to "new"
195          * (via yyrestart()), so that the user can continue scanning by
196          * just pointing yyin at a new input file.
197          */
198 #define YY_BUFFER_EOF_PENDING 2
199         };
200
201 static YY_BUFFER_STATE yy_current_buffer = 0;
202
203 /* We provide macros for accessing buffer states in case in the
204  * future we want to put the buffer states in a more general
205  * "scanner state".
206  */
207 #define YY_CURRENT_BUFFER yy_current_buffer
208
209
210 /* yy_hold_char holds the character lost when yytext is formed. */
211 static char yy_hold_char;
212
213 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
214
215
216 int yyleng;
217
218 /* Points to current character in buffer. */
219 static char *yy_c_buf_p = (char *) 0;
220 static int yy_init = 1;         /* whether we need to initialize */
221 static int yy_start = 0;        /* start state number */
222
223 /* Flag which is used to allow yywrap()'s to do buffer switches
224  * instead of setting up a fresh yyin.  A bit of a hack ...
225  */
226 static int yy_did_buffer_switch_on_eof;
227
228 void yyrestart YY_PROTO(( FILE *input_file ));
229
230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
231 void yy_load_buffer_state YY_PROTO(( void ));
232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
237
238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
241
242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
244 static void yy_flex_free YY_PROTO(( void * ));
245
246 #define yy_new_buffer yy_create_buffer
247
248 #define yy_set_interactive(is_interactive) \
249         { \
250         if ( ! yy_current_buffer ) \
251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
252         yy_current_buffer->yy_is_interactive = is_interactive; \
253         }
254
255 #define yy_set_bol(at_bol) \
256         { \
257         if ( ! yy_current_buffer ) \
258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
259         yy_current_buffer->yy_at_bol = at_bol; \
260         }
261
262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
263
264 typedef unsigned char YY_CHAR;
265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
266 typedef int yy_state_type;
267 extern char *yytext;
268 #define yytext_ptr yytext
269
270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
272 static int yy_get_next_buffer YY_PROTO(( void ));
273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
274
275 /* Done after the current pattern has been matched and before the
276  * corresponding action - sets up yytext.
277  */
278 #define YY_DO_BEFORE_ACTION \
279         yytext_ptr = yy_bp; \
280         yyleng = (int) (yy_cp - yy_bp); \
281         yy_hold_char = *yy_cp; \
282         *yy_cp = '\0'; \
283         yy_c_buf_p = yy_cp;
284
285 #define YY_NUM_RULES 146
286 #define YY_END_OF_BUFFER 147
287 static yyconst short int yy_accept[551] =
288     {   0,
289         0,    0,  147,  146,    2,    4,    3,  105,  146,   93,
290       107,  100,  146,   90,   91,  101,  102,   92,  103,   99,
291       106,   85,   84,  113,  114,  108,  115,  109,  112,   83,
292        83,   83,   83,   83,   97,   98,  110,   83,   83,   83,
293        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
294        83,   83,   83,   83,   83,   83,   83,   83,   95,  111,
295        96,  104,    2,    4,    0,    3,  127,    0,   89,    0,
296         0,   94,  142,    0,    0,    0,  132,  128,  137,    0,
297         0,  130,  120,  133,  121,  134,  118,  116,    0,   87,
298         1,  131,   87,   85,    0,    0,   85,   85,    0,   84,
299
300        84,   84,  117,  122,  124,    0,  126,   14,  125,  123,
301        83,   83,   83,    0,    0,   83,   83,  138,   83,   83,
302        83,   83,   83,   83,   83,   83,   83,   32,   83,   83,
303        83,   83,   83,   83,   83,   83,   83,   83,   43,   83,
304        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
305        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
306        83,   83,   83,  139,  129,    0,    0,    0,    0,    0,
307         0,    0,   88,    0,    0,  119,  140,    0,   87,    1,
308         0,   87,   85,   86,   84,  135,   15,  136,   16,   83,
309        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
310
311        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
312        83,   83,   41,   83,   83,   83,   83,   83,   83,   83,
313        83,   47,   83,   83,   83,   83,   74,   83,   83,   83,
314        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
315        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
316        83,   83,   83,   83,    0,    0,    0,  141,    0,    0,
317         0,    0,    0,    0,    0,   87,   86,   86,   83,   83,
318        83,   83,   83,   83,   23,   83,   25,   26,   83,   83,
319        83,   83,   83,   83,   83,   34,   35,   83,   83,   37,
320        83,   83,   83,   83,   42,   83,   83,   83,   83,   83,
321
322        83,   48,   49,   83,   83,   83,   83,   83,   83,   83,
323        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
324        83,   83,   83,   83,   83,   80,   83,   83,   83,   83,
325        83,   64,   83,   83,   83,   83,    0,    0,    0,  141,
326         0,    0,  145,    0,    0,    0,    0,   86,   83,   17,
327        83,   83,   83,   83,   24,    5,   69,   27,   83,   83,
328        83,   83,   83,   36,   13,   38,   83,   40,   83,   12,
329        83,   44,   83,   83,   83,   83,   83,   83,   83,   83,
330        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
331        83,   54,   83,   83,   83,   83,   83,   83,   61,   62,
332
333        83,   83,   83,   83,   66,   83,    0,    0,  145,    0,
334         0,   83,   83,   83,   83,   83,   83,   83,   30,   70,
335        33,   39,   71,   11,   45,   83,   72,   83,   83,   83,
336        83,   83,   83,   83,   83,   50,   83,   83,   83,   79,
337        83,   83,   53,   55,   56,   57,   58,   59,   83,   83,
338        83,   83,   83,   83,    0,    0,  144,   83,   18,   83,
339        83,   83,   83,   29,   31,   46,   10,   83,   83,   83,
340        83,   83,   83,   83,   78,   83,   83,   83,   83,   60,
341        83,   81,   83,   67,   83,    0,  144,  144,  144,   83,
342        83,   83,   83,   28,   83,   83,   19,   20,   83,   75,
343
344        76,   83,   83,    8,   52,   63,   65,   83,  144,   83,
345        83,   68,   83,    7,   83,   83,   77,   51,    9,  144,
346        83,   73,   83,   83,   83,  143,   83,    6,   83,   83,
347       143,   83,   83,   22,   83,   83,   83,   21,   83,   83,
348        83,   83,    0,    0,    0,    0,    0,   82,    0,    0
349     } ;
350
351 static yyconst int yy_ec[256] =
352     {   0,
353         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
354         4,    5,    6,    1,    1,    1,    1,    1,    1,    1,
355         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
356         1,    7,    8,    9,   10,    1,   11,   12,   13,   14,
357        15,   16,   17,   18,   19,   20,   21,   22,   23,   23,
358        23,   23,   23,   23,   23,   24,   24,   25,   26,   27,
359        28,   29,   30,    1,   31,   32,   33,   32,   34,   35,
360        36,   36,   37,   36,   36,   38,   36,   39,   40,   36,
361        36,   41,   42,   43,   44,   45,   36,   46,   36,   47,
362        48,   49,   50,   51,   52,    1,   53,   54,   55,   56,
363
364        57,   58,   59,   60,   61,   36,   62,   63,   64,   65,
365        66,   67,   36,   68,   69,   70,   71,   72,   73,   74,
366        75,   76,   77,   78,   79,   80,    1,    1,    1,    1,
367         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
368         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
369         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
370         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
371         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
372         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
373         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
374
375         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
376         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
377         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
378         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
380         1,    1,    1,    1,    1
381     } ;
382
383 static yyconst int yy_meta[81] =
384     {   0,
385         1,    2,    3,    1,    1,    1,    2,    1,    4,    1,
386         1,    1,    5,    1,    6,    1,    1,    1,    1,    1,
387         1,    7,    7,    8,    1,    1,    1,    1,    1,    4,
388         9,    9,    9,    9,    9,   10,   10,   10,   10,   10,
389        10,   10,   10,   10,   10,   11,   10,    1,    4,    1,
390         1,   10,   12,   12,    9,    9,    9,   12,   10,   10,
391        10,   10,   10,   10,   13,   10,   10,   13,   10,   13,
392        10,   13,   10,   13,   10,   10,    1,    1,    1,    1
393     } ;
394
395 static yyconst short int yy_base[568] =
396     {   0,
397         0,    0,  968,  969,   79,  969,   85,  939,   84,   92,
398       938,   83,  916,  969,  969,  936,   79,  969,   81,   81,
399        85,   97,  104,  938,  969,   95,  123,  108,  969,  924,
400         0,  926,   99,  929,  969,  969,  931,  906,   63,  889,
401       103,   83,  109,  110,   78,  903,   99,   92,  113,  898,
402       113,  116,  897,  121,   72,  888,  127,  135,  969,  134,
403       969,  969,  194,  969,  202,  211,  969,  180,  969,  188,
404       217,  969,  221,  891,  890,  882,  969,  969,  969,  116,
405       198,  969,  969,  969,  969,  969,  933,  969,  928,  213,
406         0,  969,  230,  235,  277,  272,  178,  164,    0,  285,
407
408       189,  187,  969,  919,  969,  254,  969,  969,  969,  918,
409         0,  907,  873,  183,  894,  909,  900,  969,  165,  885,
410       869,  881,  868,  883,  882,  869,  219,  862,  173,  246,
411       864,  861,  864,  861,  867,  857,  860,  860,  225,  255,
412       859,  858,  853,  856,  847,  862,  861,  260,  849,  862,
413       261,  849,  187,  259,  853,  852,  845,  272,  843,  261,
414       850,  848,  847,  969,  969,  321,    0,  330,  306,  844,
415       841,  852,  969,  323,    0,  969,  969,  330,  969,    0,
416       335,  338,  969,  327,  969,  969,  969,  969,    0,  839,
417       872,  860,  836,  845,  828,  832,  844,  839,  827,  825,
418
419       197,  225,  836,  838,  833,  833,  828,  820,  823,  820,
420       828,  831,    0,  826,  816,  810,  824,  822,  822,  814,
421       815,    0,  818,  815,  804,  806,  322,  803,  802,  810,
422       796,  797,  810,  802,  808,  802,  791,  793,  795,  802,
423       788,  786,  786,  786,  797,  796,  786,  790,  780,  793,
424       795,  794,  783,  775,  357,  398,  329,  361,  328,  787,
425       786,  783,  369,  444,  365,  381,  296,  331,  786,  802,
426       802,  775,  777,  772,    0,  773,    0,  777,  764,  762,
427       770,  759,  764,  758,  764,    0,    0,  768,  750,    0,
428       756,  755,  752,  756,    0,  753,  756,  760,  760,  745,
429
430       750,    0,    0,  761,  743,  757,  751,  742,  743,  755,
431       744,  742,  752,  747,  742,  741,  735,  731,  731,  728,
432       740,  730,  734,  739,  738,    0,  736,  733,  725,  730,
433       717,    0,  717,  718,  728,  727,  386,    0,  436,  439,
434       388,    0,    0,  462,  719,  351,    0,  969,  712,    0,
435       734,  719,  726,  699,    0,    0,    0,    0,  704,  705,
436       704,  703,  702,    0,    0,    0,  693,    0,  701,    0,
437       699,    0,  686,  675,  661,  655,  647,  651,  652,  638,
438       637,  627,  630,  629,  608,  622,  614,  616,  592,  582,
439       586,    0,  594,  591,  592,  572,  581,  583,    0,    0,
440
441       574,  584,  558,  565,    0,  538,  465,  506,    0,  487,
442       542,  533,  559,  527,  523,  527,  518,  518,  531,    0,
443         0,    0,    0,    0,    0,  529,    0,  528,  519,  512,
444       514,  510,  514,  513,  520,    0,  515,  501,  512,    0,
445       506,  511,    0,    0,    0,    0,    0,    0,  500,  500,
446       493,  491,  483,  487,  399,  543,  407,  485,    0,  493,
447       497,  495,  490,    0,    0,    0,    0,  485,  481,  487,
448       476,  472,  468,  479,    0,  477,  480,  452,  458,    0,
449       468,    0,  465,    0,  462,  416,    0,  410,  456,  441,
450       453,  434,  425,    0,  437,  419,    0,    0,  416,    0,
451
452         0,  425,  403,    0,    0,    0,    0,  415,  414,  431,
453       398,    0,  383,    0,  379,  371,    0,    0,    0,  369,
454       374,    0,  358,  371,  354,    0,  349,    0,  329,  338,
455         0,  278,  238,    0,  260,  217,  208,    0,  190,   88,
456        40,  489,  505,  421,  438,  506,  516,  969,  518,  969,
457       601,  614,  621,  631,  641,  654,  661,  667,  679,  686,
458       696,  703,  715,  728,  741,  753,  765
459     } ;
460
461 static yyconst short int yy_def[568] =
462     {   0,
463       550,    1,  550,  550,  550,  550,  550,  550,  551,  550,
464       550,  550,  552,  550,  550,  550,  550,  550,  550,  550,
465       550,  550,  550,  550,  550,  550,  550,  550,  550,  553,
466       553,  553,  553,  553,  550,  550,  550,  553,  553,  553,
467       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
468       553,  553,  553,  553,  553,  553,  553,  553,  550,  550,
469       550,  550,  550,  550,  550,  550,  550,  551,  550,  554,
470       550,  550,  550,  550,  550,  550,  550,  550,  550,  552,
471       555,  550,  550,  550,  550,  550,  550,  550,  550,  550,
472       556,  550,  550,  550,  550,  550,  550,  550,  557,  550,
473
474       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
475       553,  553,  553,  551,  552,  553,  553,  550,  553,  553,
476       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
477       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
478       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
479       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
480       553,  553,  553,  550,  550,  551,  558,  550,  559,  550,
481       550,  550,  550,  552,  560,  550,  550,  550,  550,  556,
482       550,  550,  550,  557,  550,  550,  550,  550,  553,  553,
483       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
484
485       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
486       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
487       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
488       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
489       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
490       553,  553,  553,  553,  551,  551,  559,  550,  561,  550,
491       550,  550,  552,  552,  550,  550,  550,  550,  553,  553,
492       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
493       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
494       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
495
496       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
497       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
498       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
499       553,  553,  553,  553,  553,  553,  551,  256,  550,  550,
500       559,  562,  563,  550,  550,  552,  264,  550,  553,  553,
501       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
502       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
503       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
504       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
505       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
506
507       553,  553,  553,  553,  553,  553,  559,  559,  563,  550,
508       550,  553,  553,  553,  553,  553,  553,  553,  553,  553,
509       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
510       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
511       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
512       553,  553,  553,  553,  559,  408,  564,  553,  553,  553,
513       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
514       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
515       553,  553,  553,  553,  553,  559,  564,  564,  564,  553,
516       553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
517
518       553,  553,  553,  553,  553,  553,  553,  553,  564,  553,
519       553,  553,  553,  553,  553,  553,  553,  553,  553,  564,
520       553,  553,  553,  553,  553,  565,  553,  553,  553,  553,
521       565,  553,  553,  553,  553,  553,  553,  553,  553,  553,
522       553,  553,  550,  566,  566,  567,  550,  550,  567,    0,
523       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
524       550,  550,  550,  550,  550,  550,  550
525     } ;
526
527 static yyconst short int yy_nxt[1050] =
528     {   0,
529         4,    5,    6,    7,    7,    7,    5,    8,    9,   10,
530        11,   12,   13,   14,   15,   16,   17,   18,   19,   20,
531        21,   22,   23,   23,   24,   25,   26,   27,   28,   29,
532        30,   31,   32,   31,   31,   31,   31,   33,   31,   31,
533        31,   31,   31,   31,   34,   31,   31,   35,    4,   36,
534        37,   38,   39,   40,   41,   42,   43,   44,   45,   46,
535        47,   31,   48,   49,   50,   51,   52,   53,   54,   55,
536        56,   57,   58,   31,   31,   31,   59,   60,   61,   62,
537        63,   64,   65,   65,   65,   63,   65,   64,   66,   66,
538        66,   65,   69,   71,   78,   83,   88,  542,   71,   85,
539
540        89,   72,   90,   90,   90,   91,   84,  114,   86,   87,
541        79,  115,   92,   73,   73,   73,   93,  120,   94,   94,
542        95,  104,  105,   93,  106,  100,  100,  100,  173,  106,
543        96,  156,   70,  121,   97,  109,  110,   96,  116,  127,
544        98,  101,   99,  136,  541,  137,  157,  102,  128,   74,
545       107,  108,  141,   96,   75,  123,  139,  142,   76,   97,
546        96,  164,  124,  140,   81,  125,  101,   98,  126,  143,
547        99,  129,  133,  130,  102,  134,  131,  135,  144,  146,
548       152,  153,  132,  148,  147,  149,  150,  159,   69,  161,
549       154,   69,  160,  155,  162,   63,   64,   65,   65,   65,
550
551        63,  183,  163,   65,   64,   65,   65,   65,   65,  166,
552       166,  165,   65,   64,   66,   66,   66,   65,   71,  174,
553       174,  183,  168,   71,  185,  193,  183,  168,   70,  169,
554       540,   70,  185,  205,   90,   90,   90,  194,   73,   73,
555        73,  206,   73,   73,   73,  239,  178,  179,  183,  185,
556       179,   90,   90,   90,   93,  106,   94,   94,   95,  185,
557       106,  167,  240,  178,  179,  280,  281,  179,   96,  178,
558       179,  175,   97,  539,   74,  179,  202,  282,   98,   75,
559       218,  203,  187,   76,  538,  283,  178,  179,  181,  219,
560       181,   96,  179,  182,  182,  182,   93,   97,   95,   95,
561
562        95,  207,  537,  536,   93,   98,  100,  100,  100,  220,
563        96,  241,  230,  235,  258,  208,  209,  221,   96,  236,
564       231,  250,  101,  251,  222,  232,  242,  246,  102,   69,
565       237,  168,  247,   96,  535,  173,  168,  258,  169,  348,
566       248,   96,  255,  255,  263,  263,  265,  101,  265,  341,
567       341,  266,  266,  266,  259,  102,  182,  182,  182,  182,
568       182,  182,  339,  173,  267,   69,  348,  339,  348,   70,
569       268,   81,  179,  342,  306,  179,  307,  259,  337,  337,
570       308,  173,  340,  340,  340,  309,  266,  266,  266,  267,
571       346,  346,  534,  348,   69,  179,  258,  268,  533,   81,
572
573       179,  342,  266,  266,  266,   70,   69,  258,  488,  407,
574       407,  488,  532,  488,  530,  179,  488,   81,  179,  338,
575       338,  338,  545,  529,  258,  528,  527,  545,  338,  338,
576       338,  338,  338,  526,   70,  525,  259,  339,  179,  545,
577       339,  524,  339,  179,  545,  339,   70,  259,  523,  522,
578       338,  338,  338,  338,  338,  338,  173,  340,  340,  340,
579       340,  340,  340,  410,  259,  347,  347,  347,  410,  521,
580       520,  519,  518,  258,  347,  347,  347,  347,  347,  489,
581       517,  516,  489,   73,   73,   73,  455,  455,  410,  515,
582       543,  514,   81,  410,  513,  543,  347,  347,  347,  347,
583
584       347,  347,  544,  512,  511,  510,  543,  547,   73,   73,
585        73,  543,  547,  259,  258,  509,  508,  547,  544,  547,
586       548,  507,  547,  506,  547,  505,  504,  456,  456,  456,
587       548,  503,  548,  502,  501,  500,  456,  456,  456,  456,
588       456,  499,  498,  497,  496,  495,  494,  493,  492,  491,
589       490,  485,  484,  483,  259,  482,  481,  480,  456,  456,
590       456,  456,  456,  456,  486,  486,  486,  479,  478,  477,
591       476,  475,  474,  486,  486,  486,  486,  486,  473,  472,
592       471,  470,  469,  468,  467,  466,  465,  464,  463,  462,
593       461,  460,  459,  458,  457,  486,  486,  486,  486,  486,
594
595       486,   68,   68,  454,   68,   68,   68,   68,   68,   68,
596        68,   68,   68,   68,   80,   80,  453,   80,  452,   80,
597        80,   80,   80,   80,   80,   80,   80,  111,  111,  111,
598       111,  111,  111,  111,   68,   68,  451,   68,  450,  449,
599       448,  447,   68,   68,   80,   80,  446,   80,  445,  444,
600       443,  442,   80,   80,  180,  180,  441,  180,  180,  180,
601       180,  180,  180,  180,  180,  180,  180,  184,  184,  184,
602       440,  439,  184,  256,  256,  256,  438,  437,  256,  257,
603       257,  436,  257,  257,  257,  257,  257,  257,  257,  257,
604       257,  257,  264,  264,  264,  435,  434,  264,  257,  257,
605
606       257,  433,  257,  432,  431,  430,  257,  257,  257,  408,
607       408,  408,  429,  428,  408,  409,  409,  427,  409,  409,
608       409,  409,  409,  409,  409,  409,  409,  409,  487,  487,
609       426,  487,  487,  487,  487,  487,  487,  487,  487,  487,
610       487,  531,  531,  425,  531,  531,  531,  531,  531,  531,
611       531,  531,  531,  531,  546,  424,  423,  422,  421,  420,
612       419,  546,  546,  546,  546,  546,  549,  418,  417,  416,
613       549,  549,  549,  549,  549,  549,  549,  549,  415,  414,
614       413,  412,  411,  406,  405,  404,  403,  402,  401,  400,
615       399,  398,  397,  396,  395,  394,  393,  392,  391,  390,
616
617       389,  388,  387,  386,  385,  384,  383,  382,  381,  380,
618       379,  378,  377,  376,  375,  374,  373,  372,  371,  370,
619       369,  368,  367,  366,  365,  364,  363,  362,  361,  360,
620       359,  358,  357,  356,  355,  354,  353,  352,  351,  350,
621       349,  345,  344,  343,  336,  335,  334,  333,  332,  331,
622       330,  329,  328,  327,  326,  325,  324,  323,  322,  321,
623       320,  319,  318,  317,  316,  315,  314,  313,  312,  311,
624       310,  305,  304,  303,  302,  301,  300,  299,  298,  297,
625       296,  295,  294,  293,  292,  291,  290,  289,  288,  287,
626       286,  285,  284,  279,  278,  277,  276,  275,  274,  273,
627
628       272,  271,  270,  269,  262,  261,  260,  254,  253,  252,
629       249,  245,  244,  243,  238,  234,  233,  229,  228,  227,
630       226,  225,  224,  223,  217,  216,  215,  214,  213,  212,
631       211,  210,  204,  201,  200,  199,  198,  197,  196,  195,
632       192,  191,   81,  190,  189,  188,  186,  177,  176,  172,
633       171,  170,  158,  151,  145,  138,  122,  119,  118,  117,
634       113,  112,  103,   82,   81,   77,   67,  550,    3,  550,
635       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
636       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
637       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
638
639       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
640       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
641       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
642       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
643       550,  550,  550,  550,  550,  550,  550,  550,  550
644     } ;
645
646 static yyconst short int yy_chk[1050] =
647     {   0,
648         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
649         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
650         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
651         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
652         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
653         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
654         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
655         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
656         5,    5,    5,    5,    5,    5,    7,    7,    7,    7,
657         7,    7,    9,   10,   12,   17,   20,  541,   10,   19,
658
659        20,   10,   20,   20,   20,   21,   17,   33,   19,   19,
660        12,   33,   21,   10,   10,   10,   22,   39,   22,   22,
661        22,   26,   26,   23,   27,   23,   23,   23,   80,   27,
662        22,   55,    9,   39,   22,   28,   28,   23,   33,   42,
663        22,   23,   22,   45,  540,   45,   55,   23,   42,   10,
664        27,   27,   48,   22,   10,   41,   47,   48,   10,   22,
665        23,   60,   41,   47,   80,   41,   23,   22,   41,   49,
666        22,   43,   44,   43,   23,   44,   43,   44,   49,   51,
667        54,   54,   43,   52,   51,   52,   52,   57,   68,   58,
668        54,  114,   57,   54,   58,   63,   63,   63,   63,   63,
669
670        63,   98,   58,   65,   65,   65,   65,   65,   65,   70,
671        70,   60,   66,   66,   66,   66,   66,   66,   71,   81,
672        81,   97,   73,   71,  102,  119,   98,   73,   68,   73,
673       539,  114,  101,  129,   90,   90,   90,  119,   71,   71,
674        71,  129,   73,   73,   73,  153,   90,   90,   97,  102,
675        90,   93,   93,   93,   94,  106,   94,   94,   94,  101,
676       106,   70,  153,   93,   93,  201,  201,   93,   94,   90,
677        90,   81,   94,  537,   71,   90,  127,  202,   94,   71,
678       139,  127,  106,   71,  536,  202,   93,   93,   96,  139,
679        96,   94,   93,   96,   96,   96,   95,   94,   95,   95,
680
681        95,  130,  535,  533,  100,   94,  100,  100,  100,  140,
682        95,  154,  148,  151,  169,  130,  130,  140,  100,  151,
683       148,  160,  100,  160,  140,  148,  154,  158,  100,  166,
684       151,  168,  158,   95,  532,  174,  168,  257,  168,  267,
685       158,  100,  166,  166,  174,  174,  178,  100,  178,  259,
686       259,  178,  178,  178,  169,  100,  181,  181,  181,  182,
687       182,  182,  258,  346,  184,  255,  267,  258,  268,  166,
688       184,  174,  182,  259,  227,  182,  227,  257,  255,  255,
689       227,  263,  258,  258,  258,  227,  265,  265,  265,  184,
690       263,  263,  530,  268,  337,  182,  341,  184,  529,  346,
691
692       182,  259,  266,  266,  266,  255,  256,  455,  457,  341,
693       341,  488,  527,  457,  525,  266,  488,  263,  266,  256,
694       256,  256,  544,  524,  486,  523,  521,  544,  256,  256,
695       256,  256,  256,  520,  337,  516,  341,  339,  266,  545,
696       340,  515,  339,  266,  545,  340,  256,  455,  513,  511,
697       256,  256,  256,  256,  256,  256,  264,  339,  339,  339,
698       340,  340,  340,  344,  486,  264,  264,  264,  344,  510,
699       509,  508,  503,  407,  264,  264,  264,  264,  264,  457,
700       502,  499,  488,  344,  344,  344,  407,  407,  410,  496,
701       542,  495,  264,  410,  493,  542,  264,  264,  264,  264,
702
703       264,  264,  542,  492,  491,  490,  543,  546,  410,  410,
704       410,  543,  546,  407,  408,  489,  485,  547,  543,  549,
705       546,  483,  547,  481,  549,  479,  478,  408,  408,  408,
706       547,  477,  549,  476,  474,  473,  408,  408,  408,  408,
707       408,  472,  471,  470,  469,  468,  463,  462,  461,  460,
708       458,  454,  453,  452,  408,  451,  450,  449,  408,  408,
709       408,  408,  408,  408,  456,  456,  456,  442,  441,  439,
710       438,  437,  435,  456,  456,  456,  456,  456,  434,  433,
711       432,  431,  430,  429,  428,  426,  419,  418,  417,  416,
712       415,  414,  413,  412,  411,  456,  456,  456,  456,  456,
713
714       456,  551,  551,  406,  551,  551,  551,  551,  551,  551,
715       551,  551,  551,  551,  552,  552,  404,  552,  403,  552,
716       552,  552,  552,  552,  552,  552,  552,  553,  553,  553,
717       553,  553,  553,  553,  554,  554,  402,  554,  401,  398,
718       397,  396,  554,  554,  555,  555,  395,  555,  394,  393,
719       391,  390,  555,  555,  556,  556,  389,  556,  556,  556,
720       556,  556,  556,  556,  556,  556,  556,  557,  557,  557,
721       388,  387,  557,  558,  558,  558,  386,  385,  558,  559,
722       559,  384,  559,  559,  559,  559,  559,  559,  559,  559,
723       559,  559,  560,  560,  560,  383,  382,  560,  561,  561,
724
725       561,  381,  561,  380,  379,  378,  561,  561,  561,  562,
726       562,  562,  377,  376,  562,  563,  563,  375,  563,  563,
727       563,  563,  563,  563,  563,  563,  563,  563,  564,  564,
728       374,  564,  564,  564,  564,  564,  564,  564,  564,  564,
729       564,  565,  565,  373,  565,  565,  565,  565,  565,  565,
730       565,  565,  565,  565,  566,  371,  369,  367,  363,  362,
731       361,  566,  566,  566,  566,  566,  567,  360,  359,  354,
732       567,  567,  567,  567,  567,  567,  567,  567,  353,  352,
733       351,  349,  345,  336,  335,  334,  333,  331,  330,  329,
734       328,  327,  325,  324,  323,  322,  321,  320,  319,  318,
735
736       317,  316,  315,  314,  313,  312,  311,  310,  309,  308,
737       307,  306,  305,  304,  301,  300,  299,  298,  297,  296,
738       294,  293,  292,  291,  289,  288,  285,  284,  283,  282,
739       281,  280,  279,  278,  276,  274,  273,  272,  271,  270,
740       269,  262,  261,  260,  254,  253,  252,  251,  250,  249,
741       248,  247,  246,  245,  244,  243,  242,  241,  240,  239,
742       238,  237,  236,  235,  234,  233,  232,  231,  230,  229,
743       228,  226,  225,  224,  223,  221,  220,  219,  218,  217,
744       216,  215,  214,  212,  211,  210,  209,  208,  207,  206,
745       205,  204,  203,  200,  199,  198,  197,  196,  195,  194,
746
747       193,  192,  191,  190,  172,  171,  170,  163,  162,  161,
748       159,  157,  156,  155,  152,  150,  149,  147,  146,  145,
749       144,  143,  142,  141,  138,  137,  136,  135,  134,  133,
750       132,  131,  128,  126,  125,  124,  123,  122,  121,  120,
751       117,  116,  115,  113,  112,  110,  104,   89,   87,   76,
752        75,   74,   56,   53,   50,   46,   40,   38,   37,   34,
753        32,   30,   24,   16,   13,   11,    8,    3,  550,  550,
754       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
755       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
756       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
757
758       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
759       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
760       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
761       550,  550,  550,  550,  550,  550,  550,  550,  550,  550,
762       550,  550,  550,  550,  550,  550,  550,  550,  550
763     } ;
764
765 static yy_state_type yy_last_accepting_state;
766 static char *yy_last_accepting_cpos;
767
768 /* The intent behind this definition is that it'll catch
769  * any uses of REJECT which flex missed.
770  */
771 #define REJECT reject_used_but_not_detected
772 #define yymore() yymore_used_but_not_detected
773 #define YY_MORE_ADJ 0
774 #define YY_RESTORE_YY_MORE_OFFSET
775 char *yytext;
776 #line 1 "xp-lexer.l"
777 #define INITIAL 0
778 #line 2 "xp-lexer.l"
779
780 /*  Copyright (C) 1989-1991 James A. Roskind, All rights reserved.
781     This lexer description was written by James A.  Roskind.  Copying
782     of  this  file, as a whole, is permitted providing this notice is
783     intact  and  applicable   in   all   complete   copies.    Direct
784     translations  as a whole to other lexer generator input languages
785     (or lexical description languages)  is  permitted  provided  that
786     this  notice  is  intact and applicable in all such copies, along
787     with a disclaimer that  the  contents  are  a  translation.   The
788     reproduction  of derived files or text, such as modified versions
789     of this file, or the output of scanner generators, is  permitted,
790     provided   the  resulting  work  includes  the  copyright  notice
791     "Portions Copyright (c) 1989, 1990 James  A.   Roskind".  Derived
792     products  must  also  provide  the notice "Portions Copyright (c)
793     1989, 1990 James A.  Roskind" in  a  manner  appropriate  to  the
794     utility,   and  in  keeping  with  copyright  law  (e.g.:  EITHER
795     displayed when first invoked/executed; OR displayed  continuously
796     on  display terminal; OR via placement in the object code in form
797     readable in a printout, with or near the title of the work, or at
798     the end of the file).  No royalties, licenses or  commissions  of
799     any  kind  are  required  to copy this file, its translations, or
800     derivative products, when the copies are made in compliance  with
801     this  notice.  Persons  or  corporations  that  do make copies in
802     compliance  with  this  notice  may  charge  whatever  price   is
803     agreeable  to  a buyer, for such copies or derivative works. THIS
804     FILE IS PROVIDED ``AS IS'' AND WITHOUT  ANY  EXPRESS  OR  IMPLIED
805     WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
806     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
807
808     James A. Roskind
809     Independent Consultant
810     516 Latania Palm Drive
811     Indialantic FL, 32903
812     (407)729-4348
813     jar@hq.ileaf.com
814     or ...!uunet!leafusa!jar
815
816     ---end of copyright notice---
817
818 */
819
820 /*
821
822 Comment  removal  must  be done during the lexing, as context (such as
823 enclosure in string literals) must be  observed.   For  this  cut-down
824 lexer,  we  will  assume that comments have been removed (don't assume
825 this if you are writing a compiler or browser!).
826
827
828 For each IDENTIFIER like string that is found,  there  are  several
829 distinct interpretations that can be applied:
830
831 1)  The  preprocessor  may  interpret  the  string as a "keyword" in a
832 directive (eg: "pragma" or "include", "defined").
833
834 2) The parser may interpret the string as a keyword. (eg: "int").
835
836 3) Both parser and preprocessor may interpret the string as a  keyword
837 (eg: "if").
838
839 Since  this  file  is based on source that actually lexically analyses
840 text for both preprocessing and parsing, macro definitions  were  used
841 throughout.   The macro definitions supplied here have been customized
842 to a C++ parse only, and  all  preprocessor  keywords  are  passed  as
843 IDENTIFIER  or  TYPEDEFname.   Also, since there is no symbol table to
844 interrogate to decide whether a string  is  a  TYPEDEFname,  I  simply
845 assume  that  any  identifier beginning with an upper case letter is a
846 TYPEDEFname.  This hack  should  allow  you  to  check  out  how  code
847 segments  are  parsed  using my grammar.  Unfortunately, if you really
848 want to parse major league code, you have to write a symbol table, and
849 maintain appropriate scoping information.
850
851 */
852
853
854 /* Included code before lex code */
855 /*************** Includes and Defines *****************************/
856
857
858 char *CurrentIdent, *CurrentConst ;
859 int FoundLBrace=0, FoundRBrace=0 ;
860
861 #define YYSTYPE char *
862 #include "xp-t.tab.h" /* YACC generated definitions based on C++ grammar */
863 #include "xp-lexer.h"
864 #include "xp-extn.h"
865
866
867 #define WHITE_RETURN(x) if ( shouldprint ) strcat(OutBuf,prevtoken) ; \
868                         strcpy(prevtoken,x);
869
870 /*
871 #define NEW_LINE_RETURN() CurrentLine++; \
872                           if ( shouldprint ) strcat(OutBuf,prevtoken); \
873                           strcpy(prevtoken,yytext);
874 */
875                           
876
877 #define PA_KEYWORD_RETURN(x)   RETURN_VAL(x)  /* standard C PArser Keyword */
878 #define CPP_KEYWORD_RETURN(x)  PA_KEYWORD_RETURN(x)  /* C++ keyword */
879 #define PPPA_KEYWORD_RETURN(x) RETURN_VAL(x)  /* both PreProcessor and PArser keyword */
880 #define PP_KEYWORD_RETURN(x)   IDENTIFIER_RETURN()
881
882 /*
883 #define IDENTIFIER_RETURN() RETURN_VAL(isaTYPE(yytext)?TYPEDEFname:IDENTIFIER)
884 */
885
886 #define IDENTIFIER_RETURN() CurrentIdent = (char *)malloc((strlen(yytext)+1)*sizeof(char)); \
887                             strcpy(CurrentIdent,yytext);  \
888                             yylval = CurrentIdent ; \
889                             if (shouldprint) strcat(OutBuf,prevtoken); \
890                             strcpy(prevtoken,yytext) ; \
891                             if ( FoundLBrace ) {PushStack() ;FoundLBrace=0;}\
892                             else if ( FoundRBrace ){PopStack();FoundRBrace=0;}\
893                             return(isaTYPE(yytext)?TYPEDEFname:IDENTIFIER);
894
895 #define PPOP_RETURN(x)       RETURN_VAL((int)*yytext) /* PreProcess and Parser operator */
896 #define NAMED_PPOP_RETURN(x) /* error: PreProcessor ONLY operator;  Do nothing */
897 #define ASCIIOP_RETURN(x)    RETURN_VAL((int)*yytext) /* a single character operator */
898 #define LBRACE_RETURN(x)     CurrentScope++ ; \
899                              RETURN_VAL((int)*yytext) ;
900 #define RBRACE_RETURN(x)     CurrentScope-- ; \
901                              RETURN_VAL((int)*yytext) ;
902
903 #define NAMEDOP_RETURN(x)    RETURN_VAL(x)            /* a multichar operator, with a name */
904
905 /* #define NUMERICAL_RETURN(x) RETURN_VAL(x)         * some sort of constant */
906
907 #define NUMERICAL_RETURN(x) CurrentConst = (char *)malloc((strlen(yytext)+1)*sizeof(char)); \
908                             strcpy(CurrentConst,yytext);  \
909                             yylval = CurrentConst ; \
910                             if (shouldprint) strcat(OutBuf,prevtoken); \
911                             strcpy(prevtoken,yytext) ; \
912                             if ( FoundLBrace ) {PushStack() ;FoundLBrace=0;}\
913                             else if ( FoundRBrace ){PopStack();FoundRBrace=0;}\
914                             return(x);
915                             
916
917 #define LITERAL_RETURN(x)   RETURN_VAL(x)            /* a string literal */
918
919 #define RETURN_VAL(x)   yylval = yytext; \
920                         if ( shouldprint ) strcat(OutBuf,prevtoken); \
921                         strcpy(prevtoken,yytext) ; \
922                         if ( FoundLBrace ) {PushStack() ;FoundLBrace=0;}\
923                         else if ( FoundRBrace ){PopStack();FoundRBrace=0;}\
924                         if ( prevtoken[0] == '{' ) FoundLBrace=1; \
925                         else if ( prevtoken[0] == '}' ) FoundRBrace=1; \
926                         return(x);
927
928 #define RETURN_VAL_NOPRINT(x)   yylval = yytext; return(x);
929
930 #define CHARM_KEYWORD_RETURN(x) RETURN_VAL_NOPRINT(x)
931
932 #ifdef yywrap
933 #undef yywrap
934 #endif
935
936
937 /* Macros after this point can all be overridden by user definitions in
938  * section 1.
939  */
940
941 #ifndef YY_SKIP_YYWRAP
942 #ifdef __cplusplus
943 extern "C" int yywrap YY_PROTO(( void ));
944 #else
945 extern int yywrap YY_PROTO(( void ));
946 #endif
947 #endif
948
949 #ifndef YY_NO_UNPUT
950 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
951 #endif
952
953 #ifndef yytext_ptr
954 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
955 #endif
956
957 #ifdef YY_NEED_STRLEN
958 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
959 #endif
960
961 #ifndef YY_NO_INPUT
962 #ifdef __cplusplus
963 static int yyinput YY_PROTO(( void ));
964 #else
965 static int input YY_PROTO(( void ));
966 #endif
967 #endif
968
969 #if YY_STACK_USED
970 static int yy_start_stack_ptr = 0;
971 static int yy_start_stack_depth = 0;
972 static int *yy_start_stack = 0;
973 #ifndef YY_NO_PUSH_STATE
974 static void yy_push_state YY_PROTO(( int new_state ));
975 #endif
976 #ifndef YY_NO_POP_STATE
977 static void yy_pop_state YY_PROTO(( void ));
978 #endif
979 #ifndef YY_NO_TOP_STATE
980 static int yy_top_state YY_PROTO(( void ));
981 #endif
982
983 #else
984 #define YY_NO_PUSH_STATE 1
985 #define YY_NO_POP_STATE 1
986 #define YY_NO_TOP_STATE 1
987 #endif
988
989 #ifdef YY_MALLOC_DECL
990 YY_MALLOC_DECL
991 #else
992 #if __STDC__
993 #ifndef __cplusplus
994 #include <stdlib.h>
995 #endif
996 #else
997 /* Just try to get by without declaring the routines.  This will fail
998  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
999  * or sizeof(void*) != sizeof(int).
1000  */
1001 #endif
1002 #endif
1003
1004 /* Amount of stuff to slurp up with each read. */
1005 #ifndef YY_READ_BUF_SIZE
1006 #define YY_READ_BUF_SIZE 8192
1007 #endif
1008
1009 /* Copy whatever the last rule matched to the standard output. */
1010
1011 #ifndef ECHO
1012 /* This used to be an fputs(), but since the string might contain NUL's,
1013  * we now use fwrite().
1014  */
1015 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1016 #endif
1017
1018 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1019  * is returned in "result".
1020  */
1021 #ifndef YY_INPUT
1022 #define YY_INPUT(buf,result,max_size) \
1023         if ( yy_current_buffer->yy_is_interactive ) \
1024                 { \
1025                 int c = '*', n; \
1026                 for ( n = 0; n < max_size && \
1027                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1028                         buf[n] = (char) c; \
1029                 if ( c == '\n' ) \
1030                         buf[n++] = (char) c; \
1031                 if ( c == EOF && ferror( yyin ) ) \
1032                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1033                 result = n; \
1034                 } \
1035         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1036                   && ferror( yyin ) ) \
1037                 YY_FATAL_ERROR( "input in flex scanner failed" );
1038 #endif
1039
1040 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1041  * we don't want an extra ';' after the "return" because that will cause
1042  * some compilers to complain about unreachable statements.
1043  */
1044 #ifndef yyterminate
1045 #define yyterminate() return YY_NULL
1046 #endif
1047
1048 /* Number of entries by which start-condition stack grows. */
1049 #ifndef YY_START_STACK_INCR
1050 #define YY_START_STACK_INCR 25
1051 #endif
1052
1053 /* Report a fatal error. */
1054 #ifndef YY_FATAL_ERROR
1055 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1056 #endif
1057
1058 /* Default declaration of generated scanner - a define so the user can
1059  * easily add parameters.
1060  */
1061 #ifndef YY_DECL
1062 #define YY_DECL int yylex YY_PROTO(( void ))
1063 #endif
1064
1065 /* Code executed at the beginning of each rule, after yytext and yyleng
1066  * have been set up.
1067  */
1068 #ifndef YY_USER_ACTION
1069 #define YY_USER_ACTION
1070 #endif
1071
1072 /* Code executed at the end of each rule. */
1073 #ifndef YY_BREAK
1074 #define YY_BREAK break;
1075 #endif
1076
1077 #define YY_RULE_SETUP \
1078         YY_USER_ACTION
1079
1080 YY_DECL
1081         {
1082         register yy_state_type yy_current_state;
1083         register char *yy_cp, *yy_bp;
1084         register int yy_act;
1085
1086 #line 197 "xp-lexer.l"
1087
1088
1089
1090         if ( yy_init )
1091                 {
1092                 yy_init = 0;
1093
1094 #ifdef YY_USER_INIT
1095                 YY_USER_INIT;
1096 #endif
1097
1098                 if ( ! yy_start )
1099                         yy_start = 1;   /* first start state */
1100
1101                 if ( ! yyin )
1102                         yyin = stdin;
1103
1104                 if ( ! yyout )
1105                         yyout = stdout;
1106
1107                 if ( ! yy_current_buffer )
1108                         yy_current_buffer =
1109                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1110
1111                 yy_load_buffer_state();
1112                 }
1113
1114         while ( 1 )             /* loops until end-of-file is reached */
1115                 {
1116                 yy_cp = yy_c_buf_p;
1117
1118                 /* Support of yytext. */
1119                 *yy_cp = yy_hold_char;
1120
1121                 /* yy_bp points to the position in yy_ch_buf of the start of
1122                  * the current run.
1123                  */
1124                 yy_bp = yy_cp;
1125
1126                 yy_current_state = yy_start;
1127 yy_match:
1128                 do
1129                         {
1130                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1131                         if ( yy_accept[yy_current_state] )
1132                                 {
1133                                 yy_last_accepting_state = yy_current_state;
1134                                 yy_last_accepting_cpos = yy_cp;
1135                                 }
1136                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1137                                 {
1138                                 yy_current_state = (int) yy_def[yy_current_state];
1139                                 if ( yy_current_state >= 551 )
1140                                         yy_c = yy_meta[(unsigned int) yy_c];
1141                                 }
1142                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1143                         ++yy_cp;
1144                         }
1145                 while ( yy_base[yy_current_state] != 969 );
1146
1147 yy_find_action:
1148                 yy_act = yy_accept[yy_current_state];
1149                 if ( yy_act == 0 )
1150                         { /* have to back up */
1151                         yy_cp = yy_last_accepting_cpos;
1152                         yy_current_state = yy_last_accepting_state;
1153                         yy_act = yy_accept[yy_current_state];
1154                         }
1155
1156                 YY_DO_BEFORE_ACTION;
1157
1158
1159 do_action:      /* This label is used only to access EOF actions. */
1160
1161
1162                 switch ( yy_act )
1163         { /* beginning of action switch */
1164                         case 0: /* must back up */
1165                         /* undo the effects of YY_DO_BEFORE_ACTION */
1166                         *yy_cp = yy_hold_char;
1167                         yy_cp = yy_last_accepting_cpos;
1168                         yy_current_state = yy_last_accepting_state;
1169                         goto yy_find_action;
1170
1171 case 1:
1172 YY_RULE_SETUP
1173 #line 199 "xp-lexer.l"
1174 { }
1175         YY_BREAK
1176 case 2:
1177 YY_RULE_SETUP
1178 #line 201 "xp-lexer.l"
1179 {
1180                         WHITE_RETURN(" ");
1181                         }
1182         YY_BREAK
1183 case 3:
1184 YY_RULE_SETUP
1185 #line 205 "xp-lexer.l"
1186 {
1187                         WHITE_RETURN(" ");
1188                         }
1189         YY_BREAK
1190 case 4:
1191 YY_RULE_SETUP
1192 #line 210 "xp-lexer.l"
1193 {
1194                         NEW_LINE_RETURN();
1195                         }
1196         YY_BREAK
1197 case 5:
1198 YY_RULE_SETUP
1199 #line 214 "xp-lexer.l"
1200 {CHARM_KEYWORD_RETURN(CHARE);}
1201         YY_BREAK
1202 case 6:
1203 YY_RULE_SETUP
1204 #line 215 "xp-lexer.l"
1205 {CHARM_KEYWORD_RETURN(ACCUMULATOR);}
1206         YY_BREAK
1207 case 7:
1208 YY_RULE_SETUP
1209 #line 216 "xp-lexer.l"
1210 {CHARM_KEYWORD_RETURN(MONOTONIC);}
1211         YY_BREAK
1212 case 8:
1213 YY_RULE_SETUP
1214 #line 217 "xp-lexer.l"
1215 {CHARM_KEYWORD_RETURN(READONLY);}
1216         YY_BREAK
1217 case 9:
1218 YY_RULE_SETUP
1219 #line 218 "xp-lexer.l"
1220 {CHARM_KEYWORD_RETURN(WRITEONCE);}
1221         YY_BREAK
1222 case 10:
1223 YY_RULE_SETUP
1224 #line 220 "xp-lexer.l"
1225 {CHARM_KEYWORD_RETURN(MESSAGE);}
1226         YY_BREAK
1227 case 11:
1228 YY_RULE_SETUP
1229 #line 221 "xp-lexer.l"
1230 {       if ( CheckCharmName() ) {
1231                                 CHARM_KEYWORD_RETURN(HANDLE);
1232                         }
1233                         else {
1234                                 IDENTIFIER_RETURN() ;
1235                         }
1236                     }
1237         YY_BREAK
1238 case 12:
1239 YY_RULE_SETUP
1240 #line 228 "xp-lexer.l"
1241 {       if ( CheckCharmName() ) {
1242                                 CHARM_KEYWORD_RETURN(GROUP);
1243                                 /* handle and group are processed same way */
1244                         }
1245                         else {
1246                                 IDENTIFIER_RETURN() ;
1247                         }
1248                     }
1249         YY_BREAK
1250 case 13:
1251 YY_RULE_SETUP
1252 #line 236 "xp-lexer.l"
1253 {if ( shouldprint ) strcat(OutBuf,prevtoken); 
1254                      strcpy(prevtoken,"public") ;       
1255                      CHARM_KEYWORD_RETURN(ENTRY);}
1256         YY_BREAK
1257 case 14:
1258 YY_RULE_SETUP
1259 #line 239 "xp-lexer.l"
1260 {CHARM_KEYWORD_RETURN(DOUBLEARROW);}
1261         YY_BREAK
1262 case 15:
1263 YY_RULE_SETUP
1264 #line 240 "xp-lexer.l"
1265 {CHARM_KEYWORD_RETURN(DOUBLEARROW);}
1266         YY_BREAK
1267 case 16:
1268 YY_RULE_SETUP
1269 #line 241 "xp-lexer.l"
1270 {CHARM_KEYWORD_RETURN(ALL_NODES);}
1271         YY_BREAK
1272 case 17:
1273 YY_RULE_SETUP
1274 #line 242 "xp-lexer.l"
1275 {CHARM_KEYWORD_RETURN(LOCAL);}
1276         YY_BREAK
1277 case 18:
1278 YY_RULE_SETUP
1279 #line 243 "xp-lexer.l"
1280 { FoundVarSize = TRUE ; }
1281         YY_BREAK
1282 case 19:
1283 YY_RULE_SETUP
1284 #line 244 "xp-lexer.l"
1285 {CPP_KEYWORD_RETURN(NEWCHARE);}
1286         YY_BREAK
1287 case 20:
1288 YY_RULE_SETUP
1289 #line 245 "xp-lexer.l"
1290 {CPP_KEYWORD_RETURN(NEWGROUP);}
1291         YY_BREAK
1292 case 21:
1293 YY_RULE_SETUP
1294 #line 246 "xp-lexer.l"
1295 {CPP_KEYWORD_RETURN(NEW);}
1296         YY_BREAK
1297 case 22:
1298 YY_RULE_SETUP
1299 #line 247 "xp-lexer.l"
1300 {CPP_KEYWORD_RETURN(NEW);}
1301         YY_BREAK
1302 case 23:
1303 YY_RULE_SETUP
1304 #line 250 "xp-lexer.l"
1305 {PA_KEYWORD_RETURN(AUTO);}
1306         YY_BREAK
1307 case 24:
1308 YY_RULE_SETUP
1309 #line 251 "xp-lexer.l"
1310 {PA_KEYWORD_RETURN(BREAK);}
1311         YY_BREAK
1312 case 25:
1313 YY_RULE_SETUP
1314 #line 252 "xp-lexer.l"
1315 {PA_KEYWORD_RETURN(CASE);}
1316         YY_BREAK
1317 case 26:
1318 YY_RULE_SETUP
1319 #line 253 "xp-lexer.l"
1320 {PA_KEYWORD_RETURN(CHAR);}
1321         YY_BREAK
1322 case 27:
1323 YY_RULE_SETUP
1324 #line 254 "xp-lexer.l"
1325 {PA_KEYWORD_RETURN(CONST);}
1326         YY_BREAK
1327 case 28:
1328 YY_RULE_SETUP
1329 #line 255 "xp-lexer.l"
1330 {PA_KEYWORD_RETURN(CONTINUE);}
1331         YY_BREAK
1332 case 29:
1333 YY_RULE_SETUP
1334 #line 256 "xp-lexer.l"
1335 {PA_KEYWORD_RETURN(DEFAULT);}
1336         YY_BREAK
1337 case 30:
1338 YY_RULE_SETUP
1339 #line 257 "xp-lexer.l"
1340 {PP_KEYWORD_RETURN(DEFINE);}
1341         YY_BREAK
1342 case 31:
1343 YY_RULE_SETUP
1344 #line 258 "xp-lexer.l"
1345 {PP_KEYWORD_RETURN(OPDEFINED);}
1346         YY_BREAK
1347 case 32:
1348 YY_RULE_SETUP
1349 #line 259 "xp-lexer.l"
1350 {PA_KEYWORD_RETURN(DO);}
1351         YY_BREAK
1352 case 33:
1353 YY_RULE_SETUP
1354 #line 260 "xp-lexer.l"
1355 {PA_KEYWORD_RETURN(DOUBLE);}
1356         YY_BREAK
1357 case 34:
1358 YY_RULE_SETUP
1359 #line 261 "xp-lexer.l"
1360 {PP_KEYWORD_RETURN(ELIF);}
1361         YY_BREAK
1362 case 35:
1363 YY_RULE_SETUP
1364 #line 262 "xp-lexer.l"
1365 {PPPA_KEYWORD_RETURN(ELSE);}
1366         YY_BREAK
1367 case 36:
1368 YY_RULE_SETUP
1369 #line 263 "xp-lexer.l"
1370 {PP_KEYWORD_RETURN(ENDIF);}
1371         YY_BREAK
1372 case 37:
1373 YY_RULE_SETUP
1374 #line 264 "xp-lexer.l"
1375 {PA_KEYWORD_RETURN(ENUM);}
1376         YY_BREAK
1377 case 38:
1378 YY_RULE_SETUP
1379 #line 265 "xp-lexer.l"
1380 {PP_KEYWORD_RETURN(ERROR);}
1381         YY_BREAK
1382 case 39:
1383 YY_RULE_SETUP
1384 #line 266 "xp-lexer.l"
1385 {PA_KEYWORD_RETURN(EXTERN);}
1386         YY_BREAK
1387 case 40:
1388 YY_RULE_SETUP
1389 #line 267 "xp-lexer.l"
1390 {PA_KEYWORD_RETURN(FLOAT);}
1391         YY_BREAK
1392 case 41:
1393 YY_RULE_SETUP
1394 #line 268 "xp-lexer.l"
1395 {PA_KEYWORD_RETURN(FOR);}
1396         YY_BREAK
1397 case 42:
1398 YY_RULE_SETUP
1399 #line 269 "xp-lexer.l"
1400 {PA_KEYWORD_RETURN(GOTO);}
1401         YY_BREAK
1402 case 43:
1403 YY_RULE_SETUP
1404 #line 270 "xp-lexer.l"
1405 {PPPA_KEYWORD_RETURN(IF);}
1406         YY_BREAK
1407 case 44:
1408 YY_RULE_SETUP
1409 #line 271 "xp-lexer.l"
1410 {PP_KEYWORD_RETURN(IFDEF);}
1411         YY_BREAK
1412 case 45:
1413 YY_RULE_SETUP
1414 #line 272 "xp-lexer.l"
1415 {PP_KEYWORD_RETURN(IFNDEF);}
1416         YY_BREAK
1417 case 46:
1418 YY_RULE_SETUP
1419 #line 273 "xp-lexer.l"
1420 {PP_KEYWORD_RETURN(INCLUDE); }
1421         YY_BREAK
1422 case 47:
1423 YY_RULE_SETUP
1424 #line 274 "xp-lexer.l"
1425 {PA_KEYWORD_RETURN(INT);}
1426         YY_BREAK
1427 case 48:
1428 YY_RULE_SETUP
1429 #line 275 "xp-lexer.l"
1430 {PP_KEYWORD_RETURN(LINE);}
1431         YY_BREAK
1432 case 49:
1433 YY_RULE_SETUP
1434 #line 276 "xp-lexer.l"
1435 {PA_KEYWORD_RETURN(LONG);}
1436         YY_BREAK
1437 case 50:
1438 YY_RULE_SETUP
1439 #line 277 "xp-lexer.l"
1440 {PP_KEYWORD_RETURN(PRAGMA);}
1441         YY_BREAK
1442 case 51:
1443 YY_RULE_SETUP
1444 #line 278 "xp-lexer.l"
1445 {if (ptrdiff_is_predefined)
1446                        { PA_KEYWORD_RETURN(PTRDIFF_TOKEN); }
1447                      else { IDENTIFIER_RETURN(); } }
1448         YY_BREAK
1449 case 52:
1450 YY_RULE_SETUP
1451 #line 281 "xp-lexer.l"
1452 {PA_KEYWORD_RETURN(REGISTER);}
1453         YY_BREAK
1454 case 53:
1455 YY_RULE_SETUP
1456 #line 282 "xp-lexer.l"
1457 {PA_KEYWORD_RETURN(RETURN);}
1458         YY_BREAK
1459 case 54:
1460 YY_RULE_SETUP
1461 #line 283 "xp-lexer.l"
1462 {PA_KEYWORD_RETURN(SHORT);}
1463         YY_BREAK
1464 case 55:
1465 YY_RULE_SETUP
1466 #line 284 "xp-lexer.l"
1467 {PA_KEYWORD_RETURN(SIGNED);}
1468         YY_BREAK
1469 case 56:
1470 YY_RULE_SETUP
1471 #line 285 "xp-lexer.l"
1472 {PA_KEYWORD_RETURN(SIZEOF);}
1473         YY_BREAK
1474 case 57:
1475 YY_RULE_SETUP
1476 #line 286 "xp-lexer.l"
1477 {PA_KEYWORD_RETURN(STATIC);}
1478         YY_BREAK
1479 case 58:
1480 YY_RULE_SETUP
1481 #line 287 "xp-lexer.l"
1482 {PA_KEYWORD_RETURN(STRUCT);}
1483         YY_BREAK
1484 case 59:
1485 YY_RULE_SETUP
1486 #line 288 "xp-lexer.l"
1487 {PA_KEYWORD_RETURN(SWITCH);}
1488         YY_BREAK
1489 case 60:
1490 YY_RULE_SETUP
1491 #line 289 "xp-lexer.l"
1492 {PA_KEYWORD_RETURN(TYPEDEF);}
1493         YY_BREAK
1494 case 61:
1495 YY_RULE_SETUP
1496 #line 290 "xp-lexer.l"
1497 {PP_KEYWORD_RETURN(UNDEF);}
1498         YY_BREAK
1499 case 62:
1500 YY_RULE_SETUP
1501 #line 291 "xp-lexer.l"
1502 {PA_KEYWORD_RETURN(UNION);}
1503         YY_BREAK
1504 case 63:
1505 YY_RULE_SETUP
1506 #line 292 "xp-lexer.l"
1507 {PA_KEYWORD_RETURN(UNSIGNED);}
1508         YY_BREAK
1509 case 64:
1510 YY_RULE_SETUP
1511 #line 293 "xp-lexer.l"
1512 {PA_KEYWORD_RETURN(VOID);}
1513         YY_BREAK
1514 case 65:
1515 YY_RULE_SETUP
1516 #line 294 "xp-lexer.l"
1517 {PA_KEYWORD_RETURN(VOLATILE);}
1518         YY_BREAK
1519 case 66:
1520 YY_RULE_SETUP
1521 #line 295 "xp-lexer.l"
1522 {PA_KEYWORD_RETURN(WHILE);}
1523         YY_BREAK
1524 case 67:
1525 YY_RULE_SETUP
1526 #line 296 "xp-lexer.l"
1527 { if (wchar_is_predefined) {
1528                          PA_KEYWORD_RETURN(WCHAR_TOKEN);
1529                       } else {
1530                          IDENTIFIER_RETURN();
1531                     }}
1532         YY_BREAK
1533 case 68:
1534 YY_RULE_SETUP
1535 #line 301 "xp-lexer.l"
1536 { PA_KEYWORD_RETURN(__WCHAR_TOKEN); }
1537         YY_BREAK
1538 case 69:
1539 YY_RULE_SETUP
1540 #line 303 "xp-lexer.l"
1541 {CPP_KEYWORD_RETURN(CLASS);}
1542         YY_BREAK
1543 case 70:
1544 YY_RULE_SETUP
1545 #line 304 "xp-lexer.l"
1546 {CPP_KEYWORD_RETURN(DELETE);}
1547         YY_BREAK
1548 case 71:
1549 YY_RULE_SETUP
1550 #line 305 "xp-lexer.l"
1551 {CPP_KEYWORD_RETURN(FRIEND);}
1552         YY_BREAK
1553 case 72:
1554 YY_RULE_SETUP
1555 #line 306 "xp-lexer.l"
1556 {CPP_KEYWORD_RETURN(INLINE);}
1557         YY_BREAK
1558 case 73:
1559 YY_RULE_SETUP
1560 #line 307 "xp-lexer.l"
1561 {CPP_KEYWORD_RETURN(UNDERSCORE_INLINE);}
1562         YY_BREAK
1563 case 74:
1564 YY_RULE_SETUP
1565 #line 308 "xp-lexer.l"
1566 {CPP_KEYWORD_RETURN(NEW);}
1567         YY_BREAK
1568 case 75:
1569 YY_RULE_SETUP
1570 #line 309 "xp-lexer.l"
1571 {CPP_KEYWORD_RETURN(OPERATOR);}
1572         YY_BREAK
1573 case 76:
1574 YY_RULE_SETUP
1575 #line 310 "xp-lexer.l"
1576 {CPP_KEYWORD_RETURN(OVERLOAD);}
1577         YY_BREAK
1578 case 77:
1579 YY_RULE_SETUP
1580 #line 311 "xp-lexer.l"
1581 {CPP_KEYWORD_RETURN(PROTECTED);}
1582         YY_BREAK
1583 case 78:
1584 YY_RULE_SETUP
1585 #line 312 "xp-lexer.l"
1586 {CPP_KEYWORD_RETURN(PRIVATE);}
1587         YY_BREAK
1588 case 79:
1589 YY_RULE_SETUP
1590 #line 313 "xp-lexer.l"
1591 {CPP_KEYWORD_RETURN(PUBLIC);}
1592         YY_BREAK
1593 case 80:
1594 YY_RULE_SETUP
1595 #line 314 "xp-lexer.l"
1596 {CPP_KEYWORD_RETURN(THIS);}
1597         YY_BREAK
1598 case 81:
1599 YY_RULE_SETUP
1600 #line 315 "xp-lexer.l"
1601 {CPP_KEYWORD_RETURN(VIRTUAL);}
1602         YY_BREAK
1603 case 82:
1604 YY_RULE_SETUP
1605 #line 319 "xp-lexer.l"
1606 {
1607                         /* Find the identifier */
1608                         char str[128] ;
1609                         char *ident = str ;
1610                         char *ptr1 = strchr(yytext,'(') ;
1611                         ptr1++ ;
1612                         while ( *ptr1==' ' || *ptr1=='\t' )
1613                                 ptr1++ ;                        
1614                         while ( *ptr1!=' ' && *ptr1!='\t' && *ptr1!=')' )
1615                                 *(ident++) = *(ptr1++) ;
1616                         *ident = '\0' ;
1617
1618                         strcpy(yytext,"_CK_func_") ;
1619                         strcat(yytext,str) ;
1620
1621                         IDENTIFIER_RETURN();
1622                         }
1623         YY_BREAK
1624 case 83:
1625 YY_RULE_SETUP
1626 #line 339 "xp-lexer.l"
1627 { IDENTIFIER_RETURN(); }
1628         YY_BREAK
1629 case 84:
1630 YY_RULE_SETUP
1631 #line 341 "xp-lexer.l"
1632 {NUMERICAL_RETURN(INTEGERconstant);}
1633         YY_BREAK
1634 case 85:
1635 YY_RULE_SETUP
1636 #line 342 "xp-lexer.l"
1637 {NUMERICAL_RETURN(OCTALconstant);}
1638         YY_BREAK
1639 case 86:
1640 YY_RULE_SETUP
1641 #line 343 "xp-lexer.l"
1642 {NUMERICAL_RETURN(HEXconstant);}
1643         YY_BREAK
1644 case 87:
1645 YY_RULE_SETUP
1646 #line 344 "xp-lexer.l"
1647 {NUMERICAL_RETURN(FLOATINGconstant);}
1648         YY_BREAK
1649 case 88:
1650 YY_RULE_SETUP
1651 #line 347 "xp-lexer.l"
1652 {
1653                         NUMERICAL_RETURN(CHARACTERconstant);
1654                         }
1655         YY_BREAK
1656 case 89:
1657 YY_RULE_SETUP
1658 #line 352 "xp-lexer.l"
1659 {
1660                         LITERAL_RETURN(STRINGliteral);}
1661         YY_BREAK
1662 case 90:
1663 YY_RULE_SETUP
1664 #line 358 "xp-lexer.l"
1665 {PPOP_RETURN(LP);}
1666         YY_BREAK
1667 case 91:
1668 YY_RULE_SETUP
1669 #line 359 "xp-lexer.l"
1670 {PPOP_RETURN(RP);}
1671         YY_BREAK
1672 case 92:
1673 YY_RULE_SETUP
1674 #line 360 "xp-lexer.l"
1675 {PPOP_RETURN(COMMA);}
1676         YY_BREAK
1677 case 93:
1678 YY_RULE_SETUP
1679 #line 361 "xp-lexer.l"
1680 {NAMED_PPOP_RETURN('#') ;}
1681         YY_BREAK
1682 case 94:
1683 YY_RULE_SETUP
1684 #line 362 "xp-lexer.l"
1685 {NAMED_PPOP_RETURN(POUNDPOUND);}
1686         YY_BREAK
1687 case 95:
1688 YY_RULE_SETUP
1689 #line 364 "xp-lexer.l"
1690 { LBRACE_RETURN(LC); }
1691         YY_BREAK
1692 case 96:
1693 YY_RULE_SETUP
1694 #line 365 "xp-lexer.l"
1695 { RBRACE_RETURN(RC); }
1696         YY_BREAK
1697 case 97:
1698 YY_RULE_SETUP
1699 #line 367 "xp-lexer.l"
1700 {ASCIIOP_RETURN(LB);}
1701         YY_BREAK
1702 case 98:
1703 YY_RULE_SETUP
1704 #line 368 "xp-lexer.l"
1705 {ASCIIOP_RETURN(RB);}
1706         YY_BREAK
1707 case 99:
1708 YY_RULE_SETUP
1709 #line 369 "xp-lexer.l"
1710 {ASCIIOP_RETURN(DOT);}
1711         YY_BREAK
1712 case 100:
1713 YY_RULE_SETUP
1714 #line 370 "xp-lexer.l"
1715 {ASCIIOP_RETURN(AND);}
1716         YY_BREAK
1717 case 101:
1718 YY_RULE_SETUP
1719 #line 371 "xp-lexer.l"
1720 {ASCIIOP_RETURN(STAR);}
1721         YY_BREAK
1722 case 102:
1723 YY_RULE_SETUP
1724 #line 372 "xp-lexer.l"
1725 {ASCIIOP_RETURN(PLUS);}
1726         YY_BREAK
1727 case 103:
1728 YY_RULE_SETUP
1729 #line 373 "xp-lexer.l"
1730 {ASCIIOP_RETURN(MINUS);}
1731         YY_BREAK
1732 case 104:
1733 YY_RULE_SETUP
1734 #line 374 "xp-lexer.l"
1735 {ASCIIOP_RETURN(NEGATE);}
1736         YY_BREAK
1737 case 105:
1738 YY_RULE_SETUP
1739 #line 375 "xp-lexer.l"
1740 {ASCIIOP_RETURN(NOT);}
1741         YY_BREAK
1742 case 106:
1743 YY_RULE_SETUP
1744 #line 376 "xp-lexer.l"
1745 {ASCIIOP_RETURN(DIV);}
1746         YY_BREAK
1747 case 107:
1748 YY_RULE_SETUP
1749 #line 377 "xp-lexer.l"
1750 {ASCIIOP_RETURN(MOD);}
1751         YY_BREAK
1752 case 108:
1753 YY_RULE_SETUP
1754 #line 378 "xp-lexer.l"
1755 {ASCIIOP_RETURN(LT);}
1756         YY_BREAK
1757 case 109:
1758 YY_RULE_SETUP
1759 #line 379 "xp-lexer.l"
1760 {ASCIIOP_RETURN(GT);}
1761         YY_BREAK
1762 case 110:
1763 YY_RULE_SETUP
1764 #line 380 "xp-lexer.l"
1765 {ASCIIOP_RETURN(XOR);}
1766         YY_BREAK
1767 case 111:
1768 YY_RULE_SETUP
1769 #line 381 "xp-lexer.l"
1770 {ASCIIOP_RETURN(PIPE);}
1771         YY_BREAK
1772 case 112:
1773 YY_RULE_SETUP
1774 #line 382 "xp-lexer.l"
1775 {ASCIIOP_RETURN(QUESTION);}
1776         YY_BREAK
1777 case 113:
1778 YY_RULE_SETUP
1779 #line 383 "xp-lexer.l"
1780 {ASCIIOP_RETURN(COLON);}
1781         YY_BREAK
1782 case 114:
1783 YY_RULE_SETUP
1784 #line 384 "xp-lexer.l"
1785 {ASCIIOP_RETURN(SEMICOLON);}
1786         YY_BREAK
1787 case 115:
1788 YY_RULE_SETUP
1789 #line 385 "xp-lexer.l"
1790 {ASCIIOP_RETURN(ASSIGN);}
1791         YY_BREAK
1792 case 116:
1793 YY_RULE_SETUP
1794 #line 387 "xp-lexer.l"
1795 {NAMEDOP_RETURN(DOTstar);}
1796         YY_BREAK
1797 case 117:
1798 YY_RULE_SETUP
1799 #line 388 "xp-lexer.l"
1800 {NAMEDOP_RETURN(CLCL);}
1801         YY_BREAK
1802 case 118:
1803 YY_RULE_SETUP
1804 #line 389 "xp-lexer.l"
1805 {NAMEDOP_RETURN(ARROW);}
1806         YY_BREAK
1807 case 119:
1808 YY_RULE_SETUP
1809 #line 390 "xp-lexer.l"
1810 {NAMEDOP_RETURN(ARROWstar);}
1811         YY_BREAK
1812 case 120:
1813 YY_RULE_SETUP
1814 #line 391 "xp-lexer.l"
1815 {NAMEDOP_RETURN(ICR);}
1816         YY_BREAK
1817 case 121:
1818 YY_RULE_SETUP
1819 #line 392 "xp-lexer.l"
1820 {NAMEDOP_RETURN(DECR);}
1821         YY_BREAK
1822 case 122:
1823 YY_RULE_SETUP
1824 #line 393 "xp-lexer.l"
1825 {NAMEDOP_RETURN(LS);}
1826         YY_BREAK
1827 case 123:
1828 YY_RULE_SETUP
1829 #line 394 "xp-lexer.l"
1830 {NAMEDOP_RETURN(RS);}
1831         YY_BREAK
1832 case 124:
1833 YY_RULE_SETUP
1834 #line 395 "xp-lexer.l"
1835 {NAMEDOP_RETURN(LE);}
1836         YY_BREAK
1837 case 125:
1838 YY_RULE_SETUP
1839 #line 396 "xp-lexer.l"
1840 {NAMEDOP_RETURN(GE);}
1841         YY_BREAK
1842 case 126:
1843 YY_RULE_SETUP
1844 #line 397 "xp-lexer.l"
1845 {NAMEDOP_RETURN(EQ);}
1846         YY_BREAK
1847 case 127:
1848 YY_RULE_SETUP
1849 #line 398 "xp-lexer.l"
1850 {NAMEDOP_RETURN(NE);}
1851         YY_BREAK
1852 case 128:
1853 YY_RULE_SETUP
1854 #line 399 "xp-lexer.l"
1855 {NAMEDOP_RETURN(ANDAND);}
1856         YY_BREAK
1857 case 129:
1858 YY_RULE_SETUP
1859 #line 400 "xp-lexer.l"
1860 {NAMEDOP_RETURN(OROR);}
1861         YY_BREAK
1862 case 130:
1863 YY_RULE_SETUP
1864 #line 401 "xp-lexer.l"
1865 {NAMEDOP_RETURN(MULTassign);}
1866         YY_BREAK
1867 case 131:
1868 YY_RULE_SETUP
1869 #line 402 "xp-lexer.l"
1870 {NAMEDOP_RETURN(DIVassign);}
1871         YY_BREAK
1872 case 132:
1873 YY_RULE_SETUP
1874 #line 403 "xp-lexer.l"
1875 {NAMEDOP_RETURN(MODassign);}
1876         YY_BREAK
1877 case 133:
1878 YY_RULE_SETUP
1879 #line 404 "xp-lexer.l"
1880 {NAMEDOP_RETURN(PLUSassign);}
1881         YY_BREAK
1882 case 134:
1883 YY_RULE_SETUP
1884 #line 405 "xp-lexer.l"
1885 {NAMEDOP_RETURN(MINUSassign);}
1886         YY_BREAK
1887 case 135:
1888 YY_RULE_SETUP
1889 #line 406 "xp-lexer.l"
1890 {NAMEDOP_RETURN(LSassign);}
1891         YY_BREAK
1892 case 136:
1893 YY_RULE_SETUP
1894 #line 407 "xp-lexer.l"
1895 {NAMEDOP_RETURN(RSassign);}
1896         YY_BREAK
1897 case 137:
1898 YY_RULE_SETUP
1899 #line 408 "xp-lexer.l"
1900 {NAMEDOP_RETURN(ANDassign);}
1901         YY_BREAK
1902 case 138:
1903 YY_RULE_SETUP
1904 #line 409 "xp-lexer.l"
1905 {NAMEDOP_RETURN(ERassign);}
1906         YY_BREAK
1907 case 139:
1908 YY_RULE_SETUP
1909 #line 410 "xp-lexer.l"
1910 {NAMEDOP_RETURN(ORassign);}
1911         YY_BREAK
1912 case 140:
1913 YY_RULE_SETUP
1914 #line 411 "xp-lexer.l"
1915 {NAMEDOP_RETURN(ELLIPSIS);}
1916         YY_BREAK
1917 case 141:
1918 YY_RULE_SETUP
1919 #line 413 "xp-lexer.l"
1920 { int i=0,j=0;
1921                                                   char temp[MAX_NAME_LENGTH];
1922
1923                                                   strcat(OutBuf,prevtoken) ;
1924                                                   strcpy(prevtoken,"") ;
1925                                                   strcat(OutBuf,yytext) ;
1926                                                   FLUSHBUF() ;
1927
1928                                                   while ((yytext[i]<'0')||
1929                                                          (yytext[i]>'9'))
1930                                                         i++;
1931                                                   while ((yytext[i]>='0') &&
1932                                                          (yytext[i]<='9'))
1933                                                         temp[j++]=yytext[i++];
1934                                                   temp[j]='\0';
1935                                                   CurrentLine = atoi(temp)-1;
1936                                                   while (yytext[i]!='\"')
1937                                                         i++;
1938
1939                                                   /* remove double quote */
1940                                                   j = yyleng-1 ;
1941                                                   while ( yytext[j] != '"' )
1942                                                         j-- ;
1943                                                   yytext[j]='\0';
1944                                                   strcpy(CurrentFileName,
1945                                                                 yytext+i+1);
1946                                                 }
1947         YY_BREAK
1948 case 142:
1949 YY_RULE_SETUP
1950 #line 441 "xp-lexer.l"
1951 { /* #line used by SP */
1952                                                 
1953                                                 int i=0,j=0;     
1954                                                 char temp[MAX_NAME_LENGTH];
1955                                                 
1956                                                 strcat(OutBuf,prevtoken) ;
1957                                                 strcpy(prevtoken,"") ;
1958                                                 strcat(OutBuf,yytext) ;
1959                                                 FLUSHBUF() ;
1960
1961                                                 /* Skip to the line number */
1962                                                 while ((yytext[i]<'0')||
1963                                                        (yytext[i]>'9'))
1964                                                      i++;
1965                                                 
1966                                                 /* Copy the line number */
1967                                                 while ((yytext[i]>='0') &&
1968                                                        (yytext[i]<='9'))
1969                                                      temp[j++]=yytext[i++];
1970                                                 temp[j]='\0';
1971                                                 
1972                                                 /* Now place it in 
1973                                                    'CurrentLine */
1974                                                 CurrentLine = atoi(temp)-1;
1975                                            }
1976         YY_BREAK
1977 case 143:
1978 YY_RULE_SETUP
1979 #line 468 "xp-lexer.l"
1980 { /* #pragma when ... */
1981
1982                 /* This pragma is used to specify dependences between EPs */
1983                     char * rest ;
1984                     if ( MakeGraph ) {
1985                         rest = strchr(yytext,'n') ;
1986                         rest++ ;
1987                         fprintf(graphfile,"WHEN %s %s : %s\n",CurrentChare,
1988                                                 CurrentEP, rest) ;
1989                     }
1990                 }
1991         YY_BREAK
1992 case 144:
1993 YY_RULE_SETUP
1994 #line 481 "xp-lexer.l"
1995 { /* #pragma used by G++: copy to output */
1996                                         strcat(OutBuf,prevtoken) ;
1997                                         strcpy(prevtoken,"") ;
1998                                         strcat(OutBuf,yytext) ;
1999                                         FLUSHBUF() ;
2000                                 }
2001         YY_BREAK
2002 case 145:
2003 YY_RULE_SETUP
2004 #line 488 "xp-lexer.l"
2005 { /* #file stuff used in nCUBE CC */
2006                                         strcat(OutBuf,prevtoken) ;
2007                                         strcpy(prevtoken,"") ;
2008                                         strcat(OutBuf,yytext) ;
2009                                         FLUSHBUF() ;
2010                                 }
2011         YY_BREAK
2012 case 146:
2013 YY_RULE_SETUP
2014 #line 495 "xp-lexer.l"
2015 ECHO;
2016         YY_BREAK
2017 case YY_STATE_EOF(INITIAL):
2018         yyterminate();
2019
2020         case YY_END_OF_BUFFER:
2021                 {
2022                 /* Amount of text matched not including the EOB char. */
2023                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2024
2025                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2026                 *yy_cp = yy_hold_char;
2027                 YY_RESTORE_YY_MORE_OFFSET
2028
2029                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2030                         {
2031                         /* We're scanning a new file or input source.  It's
2032                          * possible that this happened because the user
2033                          * just pointed yyin at a new source and called
2034                          * yylex().  If so, then we have to assure
2035                          * consistency between yy_current_buffer and our
2036                          * globals.  Here is the right place to do so, because
2037                          * this is the first action (other than possibly a
2038                          * back-up) that will match for the new input source.
2039                          */
2040                         yy_n_chars = yy_current_buffer->yy_n_chars;
2041                         yy_current_buffer->yy_input_file = yyin;
2042                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2043                         }
2044
2045                 /* Note that here we test for yy_c_buf_p "<=" to the position
2046                  * of the first EOB in the buffer, since yy_c_buf_p will
2047                  * already have been incremented past the NUL character
2048                  * (since all states make transitions on EOB to the
2049                  * end-of-buffer state).  Contrast this with the test
2050                  * in input().
2051                  */
2052                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2053                         { /* This was really a NUL. */
2054                         yy_state_type yy_next_state;
2055
2056                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2057
2058                         yy_current_state = yy_get_previous_state();
2059
2060                         /* Okay, we're now positioned to make the NUL
2061                          * transition.  We couldn't have
2062                          * yy_get_previous_state() go ahead and do it
2063                          * for us because it doesn't know how to deal
2064                          * with the possibility of jamming (and we don't
2065                          * want to build jamming into it because then it
2066                          * will run more slowly).
2067                          */
2068
2069                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2070
2071                         yy_bp = yytext_ptr + YY_MORE_ADJ;
2072
2073                         if ( yy_next_state )
2074                                 {
2075                                 /* Consume the NUL. */
2076                                 yy_cp = ++yy_c_buf_p;
2077                                 yy_current_state = yy_next_state;
2078                                 goto yy_match;
2079                                 }
2080
2081                         else
2082                                 {
2083                                 yy_cp = yy_c_buf_p;
2084                                 goto yy_find_action;
2085                                 }
2086                         }
2087
2088                 else switch ( yy_get_next_buffer() )
2089                         {
2090                         case EOB_ACT_END_OF_FILE:
2091                                 {
2092                                 yy_did_buffer_switch_on_eof = 0;
2093
2094                                 if ( yywrap() )
2095                                         {
2096                                         /* Note: because we've taken care in
2097                                          * yy_get_next_buffer() to have set up
2098                                          * yytext, we can now set up
2099                                          * yy_c_buf_p so that if some total
2100                                          * hoser (like flex itself) wants to
2101                                          * call the scanner after we return the
2102                                          * YY_NULL, it'll still work - another
2103                                          * YY_NULL will get returned.
2104                                          */
2105                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2106
2107                                         yy_act = YY_STATE_EOF(YY_START);
2108                                         goto do_action;
2109                                         }
2110
2111                                 else
2112                                         {
2113                                         if ( ! yy_did_buffer_switch_on_eof )
2114                                                 YY_NEW_FILE;
2115                                         }
2116                                 break;
2117                                 }
2118
2119                         case EOB_ACT_CONTINUE_SCAN:
2120                                 yy_c_buf_p =
2121                                         yytext_ptr + yy_amount_of_matched_text;
2122
2123                                 yy_current_state = yy_get_previous_state();
2124
2125                                 yy_cp = yy_c_buf_p;
2126                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2127                                 goto yy_match;
2128
2129                         case EOB_ACT_LAST_MATCH:
2130                                 yy_c_buf_p =
2131                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
2132
2133                                 yy_current_state = yy_get_previous_state();
2134
2135                                 yy_cp = yy_c_buf_p;
2136                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2137                                 goto yy_find_action;
2138                         }
2139                 break;
2140                 }
2141
2142         default:
2143                 YY_FATAL_ERROR(
2144                         "fatal flex scanner internal error--no action found" );
2145         } /* end of action switch */
2146                 } /* end of scanning one token */
2147         } /* end of yylex */
2148
2149
2150 /* yy_get_next_buffer - try to read in a new buffer
2151  *
2152  * Returns a code representing an action:
2153  *      EOB_ACT_LAST_MATCH -
2154  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2155  *      EOB_ACT_END_OF_FILE - end of file
2156  */
2157
2158 static int yy_get_next_buffer()
2159         {
2160         register char *dest = yy_current_buffer->yy_ch_buf;
2161         register char *source = yytext_ptr;
2162         register int number_to_move, i;
2163         int ret_val;
2164
2165         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2166                 YY_FATAL_ERROR(
2167                 "fatal flex scanner internal error--end of buffer missed" );
2168
2169         if ( yy_current_buffer->yy_fill_buffer == 0 )
2170                 { /* Don't try to fill the buffer, so this is an EOF. */
2171                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2172                         {
2173                         /* We matched a single character, the EOB, so
2174                          * treat this as a final EOF.
2175                          */
2176                         return EOB_ACT_END_OF_FILE;
2177                         }
2178
2179                 else
2180                         {
2181                         /* We matched some text prior to the EOB, first
2182                          * process it.
2183                          */
2184                         return EOB_ACT_LAST_MATCH;
2185                         }
2186                 }
2187
2188         /* Try to read more data. */
2189
2190         /* First move last chars to start of buffer. */
2191         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2192
2193         for ( i = 0; i < number_to_move; ++i )
2194                 *(dest++) = *(source++);
2195
2196         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2197                 /* don't do the read, it's not guaranteed to return an EOF,
2198                  * just force an EOF
2199                  */
2200                 yy_n_chars = 0;
2201
2202         else
2203                 {
2204                 int num_to_read =
2205                         yy_current_buffer->yy_buf_size - number_to_move - 1;
2206
2207                 while ( num_to_read <= 0 )
2208                         { /* Not enough room in the buffer - grow it. */
2209 #ifdef YY_USES_REJECT
2210                         YY_FATAL_ERROR(
2211 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2212 #else
2213
2214                         /* just a shorter name for the current buffer */
2215                         YY_BUFFER_STATE b = yy_current_buffer;
2216
2217                         int yy_c_buf_p_offset =
2218                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2219
2220                         if ( b->yy_is_our_buffer )
2221                                 {
2222                                 int new_size = b->yy_buf_size * 2;
2223
2224                                 if ( new_size <= 0 )
2225                                         b->yy_buf_size += b->yy_buf_size / 8;
2226                                 else
2227                                         b->yy_buf_size *= 2;
2228
2229                                 b->yy_ch_buf = (char *)
2230                                         /* Include room in for 2 EOB chars. */
2231                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2232                                                          b->yy_buf_size + 2 );
2233                                 }
2234                         else
2235                                 /* Can't grow it, we don't own it. */
2236                                 b->yy_ch_buf = 0;
2237
2238                         if ( ! b->yy_ch_buf )
2239                                 YY_FATAL_ERROR(
2240                                 "fatal error - scanner input buffer overflow" );
2241
2242                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2243
2244                         num_to_read = yy_current_buffer->yy_buf_size -
2245                                                 number_to_move - 1;
2246 #endif
2247                         }
2248
2249                 if ( num_to_read > YY_READ_BUF_SIZE )
2250                         num_to_read = YY_READ_BUF_SIZE;
2251
2252                 /* Read in more data. */
2253                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2254                         yy_n_chars, num_to_read );
2255                 }
2256
2257         if ( yy_n_chars == 0 )
2258                 {
2259                 if ( number_to_move == YY_MORE_ADJ )
2260                         {
2261                         ret_val = EOB_ACT_END_OF_FILE;
2262                         yyrestart( yyin );
2263                         }
2264
2265                 else
2266                         {
2267                         ret_val = EOB_ACT_LAST_MATCH;
2268                         yy_current_buffer->yy_buffer_status =
2269                                 YY_BUFFER_EOF_PENDING;
2270                         }
2271                 }
2272
2273         else
2274                 ret_val = EOB_ACT_CONTINUE_SCAN;
2275
2276         yy_n_chars += number_to_move;
2277         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2278         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2279
2280         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2281
2282         return ret_val;
2283         }
2284
2285
2286 /* yy_get_previous_state - get the state just before the EOB char was reached */
2287
2288 static yy_state_type yy_get_previous_state()
2289         {
2290         register yy_state_type yy_current_state;
2291         register char *yy_cp;
2292
2293         yy_current_state = yy_start;
2294
2295         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2296                 {
2297                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2298                 if ( yy_accept[yy_current_state] )
2299                         {
2300                         yy_last_accepting_state = yy_current_state;
2301                         yy_last_accepting_cpos = yy_cp;
2302                         }
2303                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2304                         {
2305                         yy_current_state = (int) yy_def[yy_current_state];
2306                         if ( yy_current_state >= 551 )
2307                                 yy_c = yy_meta[(unsigned int) yy_c];
2308                         }
2309                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2310                 }
2311
2312         return yy_current_state;
2313         }
2314
2315
2316 /* yy_try_NUL_trans - try to make a transition on the NUL character
2317  *
2318  * synopsis
2319  *      next_state = yy_try_NUL_trans( current_state );
2320  */
2321
2322 #ifdef YY_USE_PROTOS
2323 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2324 #else
2325 static yy_state_type yy_try_NUL_trans( yy_current_state )
2326 yy_state_type yy_current_state;
2327 #endif
2328         {
2329         register int yy_is_jam;
2330         register char *yy_cp = yy_c_buf_p;
2331
2332         register YY_CHAR yy_c = 1;
2333         if ( yy_accept[yy_current_state] )
2334                 {
2335                 yy_last_accepting_state = yy_current_state;
2336                 yy_last_accepting_cpos = yy_cp;
2337                 }
2338         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2339                 {
2340                 yy_current_state = (int) yy_def[yy_current_state];
2341                 if ( yy_current_state >= 551 )
2342                         yy_c = yy_meta[(unsigned int) yy_c];
2343                 }
2344         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2345         yy_is_jam = (yy_current_state == 550);
2346
2347         return yy_is_jam ? 0 : yy_current_state;
2348         }
2349
2350
2351 #ifndef YY_NO_UNPUT
2352 #ifdef YY_USE_PROTOS
2353 static void yyunput( int c, register char *yy_bp )
2354 #else
2355 static void yyunput( c, yy_bp )
2356 int c;
2357 register char *yy_bp;
2358 #endif
2359         {
2360         register char *yy_cp = yy_c_buf_p;
2361
2362         /* undo effects of setting up yytext */
2363         *yy_cp = yy_hold_char;
2364
2365         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2366                 { /* need to shift things up to make room */
2367                 /* +2 for EOB chars. */
2368                 register int number_to_move = yy_n_chars + 2;
2369                 register char *dest = &yy_current_buffer->yy_ch_buf[
2370                                         yy_current_buffer->yy_buf_size + 2];
2371                 register char *source =
2372                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2373
2374                 while ( source > yy_current_buffer->yy_ch_buf )
2375                         *--dest = *--source;
2376
2377                 yy_cp += (int) (dest - source);
2378                 yy_bp += (int) (dest - source);
2379                 yy_n_chars = yy_current_buffer->yy_buf_size;
2380
2381                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2382                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2383                 }
2384
2385         *--yy_cp = (char) c;
2386
2387
2388         yytext_ptr = yy_bp;
2389         yy_hold_char = *yy_cp;
2390         yy_c_buf_p = yy_cp;
2391         }
2392 #endif  /* ifndef YY_NO_UNPUT */
2393
2394
2395 #ifdef __cplusplus
2396 static int yyinput()
2397 #else
2398 static int input()
2399 #endif
2400         {
2401         int c;
2402
2403         *yy_c_buf_p = yy_hold_char;
2404
2405         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2406                 {
2407                 /* yy_c_buf_p now points to the character we want to return.
2408                  * If this occurs *before* the EOB characters, then it's a
2409                  * valid NUL; if not, then we've hit the end of the buffer.
2410                  */
2411                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2412                         /* This was really a NUL. */
2413                         *yy_c_buf_p = '\0';
2414
2415                 else
2416                         { /* need more input */
2417                         int offset = yy_c_buf_p - yytext_ptr;
2418                         ++yy_c_buf_p;
2419
2420                         switch ( yy_get_next_buffer() )
2421                                 {
2422                                 case EOB_ACT_END_OF_FILE:
2423                                         {
2424                                         if ( yywrap() )
2425                                                 {
2426                                                 yy_c_buf_p = yytext_ptr + offset;
2427                                                 return EOF;
2428                                                 }
2429
2430                                         if ( ! yy_did_buffer_switch_on_eof )
2431                                                 YY_NEW_FILE;
2432 #ifdef __cplusplus
2433                                         return yyinput();
2434 #else
2435                                         return input();
2436 #endif
2437                                         }
2438
2439                                 case EOB_ACT_CONTINUE_SCAN:
2440                                         yy_c_buf_p = yytext_ptr + offset;
2441                                         break;
2442
2443                                 case EOB_ACT_LAST_MATCH:
2444 #ifdef __cplusplus
2445                                         YY_FATAL_ERROR(
2446                                         "unexpected last match in yyinput()" );
2447 #else
2448                                         YY_FATAL_ERROR(
2449                                         "unexpected last match in input()" );
2450 #endif
2451                                 }
2452                         }
2453                 }
2454
2455         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2456         *yy_c_buf_p = '\0';     /* preserve yytext */
2457         yy_hold_char = *++yy_c_buf_p;
2458
2459
2460         return c;
2461         }
2462
2463
2464 #ifdef YY_USE_PROTOS
2465 void yyrestart( FILE *input_file )
2466 #else
2467 void yyrestart( input_file )
2468 FILE *input_file;
2469 #endif
2470         {
2471         if ( ! yy_current_buffer )
2472                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2473
2474         yy_init_buffer( yy_current_buffer, input_file );
2475         yy_load_buffer_state();
2476         }
2477
2478
2479 #ifdef YY_USE_PROTOS
2480 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2481 #else
2482 void yy_switch_to_buffer( new_buffer )
2483 YY_BUFFER_STATE new_buffer;
2484 #endif
2485         {
2486         if ( yy_current_buffer == new_buffer )
2487                 return;
2488
2489         if ( yy_current_buffer )
2490                 {
2491                 /* Flush out information for old buffer. */
2492                 *yy_c_buf_p = yy_hold_char;
2493                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2494                 yy_current_buffer->yy_n_chars = yy_n_chars;
2495                 }
2496
2497         yy_current_buffer = new_buffer;
2498         yy_load_buffer_state();
2499
2500         /* We don't actually know whether we did this switch during
2501          * EOF (yywrap()) processing, but the only time this flag
2502          * is looked at is after yywrap() is called, so it's safe
2503          * to go ahead and always set it.
2504          */
2505         yy_did_buffer_switch_on_eof = 1;
2506         }
2507
2508
2509 #ifdef YY_USE_PROTOS
2510 void yy_load_buffer_state( void )
2511 #else
2512 void yy_load_buffer_state()
2513 #endif
2514         {
2515         yy_n_chars = yy_current_buffer->yy_n_chars;
2516         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2517         yyin = yy_current_buffer->yy_input_file;
2518         yy_hold_char = *yy_c_buf_p;
2519         }
2520
2521
2522 #ifdef YY_USE_PROTOS
2523 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2524 #else
2525 YY_BUFFER_STATE yy_create_buffer( file, size )
2526 FILE *file;
2527 int size;
2528 #endif
2529         {
2530         YY_BUFFER_STATE b;
2531
2532         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2533         if ( ! b )
2534                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2535
2536         b->yy_buf_size = size;
2537
2538         /* yy_ch_buf has to be 2 characters longer than the size given because
2539          * we need to put in 2 end-of-buffer characters.
2540          */
2541         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2542         if ( ! b->yy_ch_buf )
2543                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2544
2545         b->yy_is_our_buffer = 1;
2546
2547         yy_init_buffer( b, file );
2548
2549         return b;
2550         }
2551
2552
2553 #ifdef YY_USE_PROTOS
2554 void yy_delete_buffer( YY_BUFFER_STATE b )
2555 #else
2556 void yy_delete_buffer( b )
2557 YY_BUFFER_STATE b;
2558 #endif
2559         {
2560         if ( ! b )
2561                 return;
2562
2563         if ( b == yy_current_buffer )
2564                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2565
2566         if ( b->yy_is_our_buffer )
2567                 yy_flex_free( (void *) b->yy_ch_buf );
2568
2569         yy_flex_free( (void *) b );
2570         }
2571
2572
2573 #ifndef YY_ALWAYS_INTERACTIVE
2574 #ifndef YY_NEVER_INTERACTIVE
2575 extern int isatty YY_PROTO(( int ));
2576 #endif
2577 #endif
2578
2579 #ifdef YY_USE_PROTOS
2580 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2581 #else
2582 void yy_init_buffer( b, file )
2583 YY_BUFFER_STATE b;
2584 FILE *file;
2585 #endif
2586
2587
2588         {
2589         yy_flush_buffer( b );
2590
2591         b->yy_input_file = file;
2592         b->yy_fill_buffer = 1;
2593
2594 #if YY_ALWAYS_INTERACTIVE
2595         b->yy_is_interactive = 1;
2596 #else
2597 #if YY_NEVER_INTERACTIVE
2598         b->yy_is_interactive = 0;
2599 #else
2600         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2601 #endif
2602 #endif
2603         }
2604
2605
2606 #ifdef YY_USE_PROTOS
2607 void yy_flush_buffer( YY_BUFFER_STATE b )
2608 #else
2609 void yy_flush_buffer( b )
2610 YY_BUFFER_STATE b;
2611 #endif
2612
2613         {
2614         b->yy_n_chars = 0;
2615
2616         /* We always need two end-of-buffer characters.  The first causes
2617          * a transition to the end-of-buffer state.  The second causes
2618          * a jam in that state.
2619          */
2620         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2621         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2622
2623         b->yy_buf_pos = &b->yy_ch_buf[0];
2624
2625         b->yy_at_bol = 1;
2626         b->yy_buffer_status = YY_BUFFER_NEW;
2627
2628         if ( b == yy_current_buffer )
2629                 yy_load_buffer_state();
2630         }
2631
2632
2633 #ifndef YY_NO_SCAN_BUFFER
2634 #ifdef YY_USE_PROTOS
2635 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2636 #else
2637 YY_BUFFER_STATE yy_scan_buffer( base, size )
2638 char *base;
2639 yy_size_t size;
2640 #endif
2641         {
2642         YY_BUFFER_STATE b;
2643
2644         if ( size < 2 ||
2645              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2646              base[size-1] != YY_END_OF_BUFFER_CHAR )
2647                 /* They forgot to leave room for the EOB's. */
2648                 return 0;
2649
2650         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2651         if ( ! b )
2652                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2653
2654         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2655         b->yy_buf_pos = b->yy_ch_buf = base;
2656         b->yy_is_our_buffer = 0;
2657         b->yy_input_file = 0;
2658         b->yy_n_chars = b->yy_buf_size;
2659         b->yy_is_interactive = 0;
2660         b->yy_at_bol = 1;
2661         b->yy_fill_buffer = 0;
2662         b->yy_buffer_status = YY_BUFFER_NEW;
2663
2664         yy_switch_to_buffer( b );
2665
2666         return b;
2667         }
2668 #endif
2669
2670
2671 #ifndef YY_NO_SCAN_STRING
2672 #ifdef YY_USE_PROTOS
2673 YY_BUFFER_STATE yy_scan_string( yyconst char *str )
2674 #else
2675 YY_BUFFER_STATE yy_scan_string( str )
2676 yyconst char *str;
2677 #endif
2678         {
2679         int len;
2680         for ( len = 0; str[len]; ++len )
2681                 ;
2682
2683         return yy_scan_bytes( str, len );
2684         }
2685 #endif
2686
2687
2688 #ifndef YY_NO_SCAN_BYTES
2689 #ifdef YY_USE_PROTOS
2690 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2691 #else
2692 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2693 yyconst char *bytes;
2694 int len;
2695 #endif
2696         {
2697         YY_BUFFER_STATE b;
2698         char *buf;
2699         yy_size_t n;
2700         int i;
2701
2702         /* Get memory for full buffer, including space for trailing EOB's. */
2703         n = len + 2;
2704         buf = (char *) yy_flex_alloc( n );
2705         if ( ! buf )
2706                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2707
2708         for ( i = 0; i < len; ++i )
2709                 buf[i] = bytes[i];
2710
2711         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2712
2713         b = yy_scan_buffer( buf, n );
2714         if ( ! b )
2715                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2716
2717         /* It's okay to grow etc. this buffer, and we should throw it
2718          * away when we're done.
2719          */
2720         b->yy_is_our_buffer = 1;
2721
2722         return b;
2723         }
2724 #endif
2725
2726
2727 #ifndef YY_NO_PUSH_STATE
2728 #ifdef YY_USE_PROTOS
2729 static void yy_push_state( int new_state )
2730 #else
2731 static void yy_push_state( new_state )
2732 int new_state;
2733 #endif
2734         {
2735         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2736                 {
2737                 yy_size_t new_size;
2738
2739                 yy_start_stack_depth += YY_START_STACK_INCR;
2740                 new_size = yy_start_stack_depth * sizeof( int );
2741
2742                 if ( ! yy_start_stack )
2743                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2744
2745                 else
2746                         yy_start_stack = (int *) yy_flex_realloc(
2747                                         (void *) yy_start_stack, new_size );
2748
2749                 if ( ! yy_start_stack )
2750                         YY_FATAL_ERROR(
2751                         "out of memory expanding start-condition stack" );
2752                 }
2753
2754         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2755
2756         BEGIN(new_state);
2757         }
2758 #endif
2759
2760
2761 #ifndef YY_NO_POP_STATE
2762 static void yy_pop_state()
2763         {
2764         if ( --yy_start_stack_ptr < 0 )
2765                 YY_FATAL_ERROR( "start-condition stack underflow" );
2766
2767         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2768         }
2769 #endif
2770
2771
2772 #ifndef YY_NO_TOP_STATE
2773 static int yy_top_state()
2774         {
2775         return yy_start_stack[yy_start_stack_ptr - 1];
2776         }
2777 #endif
2778
2779 #ifndef YY_EXIT_FAILURE
2780 #define YY_EXIT_FAILURE 2
2781 #endif
2782
2783 #ifdef YY_USE_PROTOS
2784 static void yy_fatal_error( yyconst char msg[] )
2785 #else
2786 static void yy_fatal_error( msg )
2787 char msg[];
2788 #endif
2789         {
2790         (void) fprintf( stderr, "%s\n", msg );
2791         exit( YY_EXIT_FAILURE );
2792         }
2793
2794
2795
2796 /* Redefine yyless() so it works in section 3 code. */
2797
2798 #undef yyless
2799 #define yyless(n) \
2800         do \
2801                 { \
2802                 /* Undo effects of setting up yytext. */ \
2803                 yytext[yyleng] = yy_hold_char; \
2804                 yy_c_buf_p = yytext + n; \
2805                 yy_hold_char = *yy_c_buf_p; \
2806                 *yy_c_buf_p = '\0'; \
2807                 yyleng = n; \
2808                 } \
2809         while ( 0 )
2810
2811
2812 /* Internal utility routines. */
2813
2814 #ifndef yytext_ptr
2815 #ifdef YY_USE_PROTOS
2816 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2817 #else
2818 static void yy_flex_strncpy( s1, s2, n )
2819 char *s1;
2820 yyconst char *s2;
2821 int n;
2822 #endif
2823         {
2824         register int i;
2825         for ( i = 0; i < n; ++i )
2826                 s1[i] = s2[i];
2827         }
2828 #endif
2829
2830 #ifdef YY_NEED_STRLEN
2831 #ifdef YY_USE_PROTOS
2832 static int yy_flex_strlen( yyconst char *s )
2833 #else
2834 static int yy_flex_strlen( s )
2835 yyconst char *s;
2836 #endif
2837         {
2838         register int n;
2839         for ( n = 0; s[n]; ++n )
2840                 ;
2841
2842         return n;
2843         }
2844 #endif
2845
2846
2847 #ifdef YY_USE_PROTOS
2848 static void *yy_flex_alloc( yy_size_t size )
2849 #else
2850 static void *yy_flex_alloc( size )
2851 yy_size_t size;
2852 #endif
2853         {
2854         return (void *) malloc( size );
2855         }
2856
2857 #ifdef YY_USE_PROTOS
2858 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2859 #else
2860 static void *yy_flex_realloc( ptr, size )
2861 void *ptr;
2862 yy_size_t size;
2863 #endif
2864         {
2865         /* The cast to (char *) in the following accommodates both
2866          * implementations that use char* generic pointers, and those
2867          * that use void* generic pointers.  It works with the latter
2868          * because both ANSI C and C++ allow castless assignment from
2869          * any pointer type to void*, and deal with argument conversions
2870          * as though doing an assignment.
2871          */
2872         return (void *) realloc( (char *) ptr, size );
2873         }
2874
2875 #ifdef YY_USE_PROTOS
2876 static void yy_flex_free( void *ptr )
2877 #else
2878 static void yy_flex_free( ptr )
2879 void *ptr;
2880 #endif
2881         {
2882         free( ptr );
2883         }
2884
2885 #if YY_MAIN
2886 int main()
2887         {
2888         yylex();
2889         return 0;
2890         }
2891 #endif
2892 #line 495 "xp-lexer.l"
2893
2894
2895 yywrap() { return(1); }
2896
2897 /* I won't bother to provide any error recovery. I won't  even  handle
2898 unknown characters */
2899
2900 /*******************************************************************
2901 int isaTYPE(string)
2902 char * string;
2903 {
2904     *  We  should  really  be  maintaining  a  symbol  table,  and be
2905     carefully keeping track of what the current scope is  (or  in  the
2906     case  of  "rescoped"  stuff,  what  scope  to  look in). Since the
2907     grammar is not annotated with  actions  to  track  transitions  to
2908     various  scopes,  and  there  is no symbol table, we will supply a
2909     hack to allow folks to test  the  grammar  out.   THIS  IS  NOT  A
2910     COMPLETE IMPLEMENTATION!!!! *
2911
2912     if ( strncmp(string,"NULL",4) == 0 )
2913         return 0 ;
2914
2915     return ('A' <= string[0] && 'Z' >= string[0]);
2916 }
2917 ********************************************************************/
2918
2919 int isaTYPE(string)
2920 char *string ;
2921 {
2922         int i ;
2923
2924         if ( StructScope )
2925                 return FALSE ;
2926
2927         if ( !FoundGlobalScope || GlobalStack == NULL ) {
2928                 for ( i=TotalSyms-1; i>=0; i-- ) {  /* from inner to outer */
2929                         if ( strcmp(string,SymTable[i].name) == 0 ) {
2930                                 strcpy(CurrentTypedef,string) ;
2931                                 return TRUE ;
2932                         }
2933                 }
2934         }
2935         else {
2936                 for ( i=0; i<GlobalStack->TotalSyms; i++ ) {  
2937                         /* search global state */
2938                         if ( strcmp(string,SymTable[i].name) == 0 ) {
2939                                 strcpy(CurrentTypedef,string) ;
2940                                 return TRUE ;
2941                         }
2942                 }
2943                 FoundGlobalScope = 0 ;
2944         }
2945         strcpy(CurrentTypedef,"") ;
2946         return FALSE ;
2947 }
2948
2949 NEW_LINE_RETURN() 
2950 {
2951         CurrentLine++; 
2952         if ( shouldprint ) strcat(OutBuf,prevtoken); 
2953         strcpy(prevtoken,yytext);
2954 }
2955
2956