Initial revision
[charm.git] / src / xlat / xl-lexsp.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 65
286 #define YY_END_OF_BUFFER 66
287 static yyconst short int yy_accept[157] =
288     {   0,
289         0,    0,   66,   64,   60,   61,   17,   64,   64,   11,
290         5,   64,   12,   13,    9,    7,   43,    8,   16,   10,
291        56,   55,    3,   46,   24,   32,   25,    2,    1,   50,
292        14,   15,    6,   44,    4,   45,   18,   60,   29,    0,
293        59,    0,    0,    0,    0,    0,    0,   37,   30,   40,
294         0,    0,   35,   20,   33,    0,   47,   48,   21,   34,
295        19,   53,   36,   52,   56,    0,    0,   56,   56,    0,
296        55,   55,   55,   22,   26,   28,   27,   23,    0,   50,
297         0,   42,   41,   31,    0,    0,    0,    0,    0,    0,
298         0,   58,    0,    0,    0,   53,   52,    0,   52,    0,
299
300        54,   56,   56,   57,   55,   55,   39,   38,    0,    0,
301         0,    0,   49,    0,    0,    0,    0,    0,    0,    0,
302        53,    0,   52,   54,   57,   57,    0,   51,    0,    0,
303         0,    0,    0,    0,    0,    0,    0,   57,   57,   51,
304         0,    0,    0,   63,    0,    0,    0,    0,    0,   63,
305        63,   62,    0,   62,   62,    0
306     } ;
307
308 static yyconst int yy_ec[256] =
309     {   0,
310         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
311         1,    4,    1,    1,    1,    1,    1,    1,    1,    1,
312         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
313         1,    2,    5,    6,    7,    1,    8,    9,   10,   11,
314        12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
315        20,   20,   20,   20,   20,   21,   21,   22,   23,   24,
316        25,   26,   27,   28,   29,   29,   29,   29,   30,   31,
317        32,   32,   32,   32,   32,   33,   32,   32,   32,   32,
318        32,   32,   32,   32,   34,   32,   32,   35,   32,   32,
319        36,   37,   38,   39,   32,    1,   40,   41,   29,   42,
320
321        43,   44,   45,   32,   46,   32,   32,   47,   48,   49,
322        32,   50,   32,   51,   32,   52,   34,   53,   32,   35,
323        32,   32,   54,   55,   56,   57,    1,    1,    1,    1,
324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
331
332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
337         1,    1,    1,    1,    1
338     } ;
339
340 static yyconst int yy_meta[58] =
341     {   0,
342         1,    2,    3,    1,    1,    4,    1,    1,    1,    5,
343         1,    1,    1,    1,    1,    1,    1,    1,    6,    6,
344         7,    8,    1,    1,    1,    1,    4,    1,    9,    9,
345         9,   10,   10,   10,   11,    1,    4,    1,    1,   12,
346        12,    9,    9,   12,   10,   10,   10,   10,   11,   10,
347        11,   11,   11,    1,    1,    1,    1
348     } ;
349
350 static yyconst short int yy_base[172] =
351     {   0,
352         0,    0,  314,  596,   56,  596,  288,   53,   59,  286,
353        56,  269,  596,  596,  278,   48,   61,   50,   48,  277,
354       101,  132,  596,  596,   46,  267,   57,  596,  596,   82,
355       596,  596,  261,  596,   47,  596,  596,   84,  596,   71,
356       596,   72,   91,  126,  243,  235,  227,  596,  596,  596,
357        64,   78,  596,  596,  596,  122,  596,  596,  596,  596,
358       596,  161,  596,  190,  241,  140,  153,  241,   56,    0,
359         0,  237,   67,  240,  596,  596,  596,  238,  184,  193,
360       191,  596,  596,  596,  165,    0,   93,   90,  164,  154,
361       157,  596,  179,    0,  198,  596,    0,  208,  596,  135,
362
363       211,  596,  596,   96,  596,  596,  596,  596,  137,  219,
364       253,  113,  596,  216,  144,  147,  143,  230,  288,  226,
365       233,  241,  268,  596,  134,  130,  198,    0,  127,  314,
366       285,    0,  106,  318,   94,  231,  340,  596,  596,    0,
367       220,  304,  379,  124,  344,   83,  233,  242,  405,    0,
368       114,   92,  263,    0,   85,  596,  449,  461,  472,  482,
369       491,  498,  505,  517,  524,  535,  545,  552,  559,  571,
370       583
371     } ;
372
373 static yyconst short int yy_def[172] =
374     {   0,
375       156,    1,  156,  156,  156,  156,  156,  157,  156,  156,
376       156,  158,  156,  156,  156,  156,  156,  156,  156,  156,
377       156,  156,  156,  156,  156,  156,  156,  156,  156,  159,
378       156,  156,  156,  156,  156,  156,  156,  156,  156,  157,
379       156,  160,  156,  156,  156,  156,  156,  156,  156,  156,
380       158,  161,  156,  156,  156,  156,  156,  156,  156,  156,
381       156,  156,  156,  156,   21,  156,  156,  156,  156,  162,
382        22,  156,  156,  156,  156,  156,  156,  156,  156,  159,
383       156,  156,  156,  156,  157,  163,  156,  164,  156,  156,
384       156,  156,  158,  165,  156,  156,   64,  156,  156,  156,
385
386       156,  156,  156,  162,  156,  156,  156,  156,  166,  157,
387       157,  164,  156,  167,  156,  156,  156,  158,  158,  156,
388       156,  156,  156,  156,  156,  156,  166,  168,  157,  111,
389       164,  169,  156,  156,  156,  158,  119,  156,  156,  168,
390       157,  164,  164,  170,  156,  156,  158,  164,  143,  170,
391       170,  171,  164,  171,  171,    0,  156,  156,  156,  156,
392       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
393       156
394     } ;
395
396 static yyconst short int yy_nxt[654] =
397     {   0,
398         4,    5,    6,    5,    7,    8,    9,   10,   11,   12,
399        13,   14,   15,   16,   17,   18,   19,   20,   21,   22,
400        22,   23,   24,   25,   26,   27,   28,   29,   30,   30,
401        30,   30,   30,   30,   30,   31,    4,   32,   33,   30,
402        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
403        30,   30,   30,   34,   35,   36,   37,   38,   41,   38,
404        43,   54,   56,   56,   49,   59,   62,   62,   62,   74,
405        75,   83,   55,   92,   60,   61,   41,   44,   44,   44,
406        50,   77,   78,   79,   79,   38,  155,   38,  103,   42,
407        85,   85,   43,  155,   87,  113,   93,   93,   88,  106,
408
409        52,   84,  103,   81,   45,   46,   86,   42,   47,   44,
410        44,   44,   94,  106,   57,  151,   58,   64,  113,   65,
411        65,   66,  152,   56,   56,  151,  114,   87,  125,  126,
412        67,   88,   41,   68,   69,   70,   45,   46,  127,  127,
413        47,  146,  125,   67,   44,   44,   44,   68,   64,  114,
414        71,   71,   71,  101,  101,  101,   64,  144,   66,   66,
415        66,   67,  139,   42,   72,   73,  100,  138,  100,   67,
416        41,  101,  101,  101,   67,   57,  139,   58,   72,   62,
417        62,   62,   67,  110,  110,   79,   79,  135,   92,  134,
418        95,   96,  133,   96,   79,   79,  117,  118,  118,  127,
419
420       127,   42,  116,   95,   96,   81,  115,   96,   97,   97,
421        97,  120,  109,  120,   81,   52,  121,  121,  121,   98,
422        99,  122,   99,  122,   41,   41,  123,  123,  123,  101,
423       101,  101,   98,   99,  131,  131,   99,  129,  129,   92,
424        92,  124,   92,  124,  121,  121,  121,  113,  136,  136,
425       132,  121,  121,  121,  124,   42,   42,  124,   41,  123,
426       123,  123,  108,   96,  107,   96,   52,   52,  113,   52,
427       105,  130,  130,  130,  102,  156,   96,   91,  114,   96,
428        90,  130,  130,  130,   89,   82,  123,  123,  123,   42,
429       113,   76,  130,  130,  130,  130,  130,   92,   99,  114,
430
431        99,   63,   53,  142,  142,   52,  137,  137,  137,  113,
432        48,   99,   39,  156,   99,  156,  137,  137,  137,  145,
433       156,  114,  148,  148,   52,  156,  156,  137,  137,  137,
434       137,  137,  141,  141,  141,  156,   44,   44,   44,  156,
435       114,  156,  141,  141,  141,  145,  156,  156,  156,  156,
436       156,  156,  156,  141,  141,  141,  141,  141,  147,  147,
437       147,  156,   44,   44,   44,  156,  156,  156,  147,  147,
438       147,  156,  156,  156,  156,  156,  156,  156,  156,  147,
439       147,  147,  147,  147,  113,  156,  156,  156,  156,  156,
440       156,  156,  156,  156,  156,  156,  156,  149,  149,  149,
441
442       156,  156,  156,  156,  156,  156,  156,  149,  149,  149,
443       156,  156,  156,  156,  156,  114,  156,  156,  149,  149,
444       149,  149,  149,  153,  153,  153,  156,  156,  156,  156,
445       156,  156,  156,  153,  153,  153,  156,  156,  156,  156,
446       156,  156,  156,  156,  153,  153,  153,  153,  153,   40,
447        40,  156,   40,   40,   40,   40,   40,   40,   40,   40,
448        40,   51,   51,  156,   51,  156,   51,   51,   51,   51,
449        51,   51,   51,   80,   80,  156,  156,   80,   80,   80,
450        80,   80,   80,   80,   40,   40,   40,   40,  156,  156,
451       156,  156,   40,   40,   51,   51,   51,  156,  156,  156,
452
453       156,   51,   51,  104,  104,  156,  104,  156,  156,  104,
454       111,  111,  156,  111,  156,  156,  111,  112,  112,  156,
455       112,  112,  112,  112,  112,  112,  112,  112,  112,  119,
456       119,  156,  119,  156,  156,  119,  128,  128,  156,  156,
457       156,  156,  156,  128,  128,  128,  128,  112,  112,  112,
458       112,  156,  156,  156,  156,  112,  112,  140,  140,  156,
459       140,  140,  140,  140,  143,  143,  156,  143,  156,  156,
460       143,  150,  150,  156,  150,  150,  150,  150,  150,  150,
461       150,  150,  150,  154,  154,  156,  154,  154,  154,  154,
462       154,  154,  154,  154,  154,    3,  156,  156,  156,  156,
463
464       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
465       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
466       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
467       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
468       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
469       156,  156,  156
470     } ;
471
472 static yyconst short int yy_chk[654] =
473     {   0,
474         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
475         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
476         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
477         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
478         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
479         1,    1,    1,    1,    1,    1,    1,    5,    8,    5,
480         9,   16,   17,   17,   11,   18,   19,   19,   19,   25,
481        25,   35,   16,   51,   18,   18,   40,    9,    9,    9,
482        11,   27,   27,   30,   30,   38,  155,   38,   69,    8,
483        42,   42,   43,  152,   87,   88,   52,   52,   87,   73,
484
485        51,   35,   69,   30,    9,    9,   42,   40,    9,   43,
486        43,   43,   52,   73,   17,  151,   17,   21,  112,   21,
487        21,   21,  146,   56,   56,  144,   88,   44,  104,  104,
488        21,   44,  129,   21,   21,   21,   43,   43,  109,  109,
489        43,  135,  104,   21,   44,   44,   44,   21,   22,  112,
490        22,   22,   22,  100,  100,  100,   66,  133,   66,   66,
491        66,   22,  126,  129,   22,   22,   67,  125,   67,   66,
492        85,   67,   67,   67,   22,   56,  126,   56,   22,   62,
493        62,   62,   66,   85,   85,   79,   79,  117,   93,  116,
494        62,   62,  115,   62,   80,   80,   91,   93,   93,  127,
495
496       127,   85,   90,   62,   62,   79,   89,   62,   64,   64,
497        64,   95,   81,   95,   80,   93,   95,   95,   95,   64,
498        64,   98,   64,   98,  110,  141,   98,   98,   98,  101,
499       101,  101,   64,   64,  114,  114,   64,  110,  110,  118,
500       136,  101,  147,  101,  120,  120,  120,  148,  118,  118,
501       114,  121,  121,  121,  101,  110,  141,  101,  111,  122,
502       122,  122,   78,  121,   74,  121,  118,  136,  153,  147,
503        72,  111,  111,  111,   68,   65,  121,   47,  148,  121,
504        46,  111,  111,  111,   45,   33,  123,  123,  123,  111,
505       131,   26,  111,  111,  111,  111,  111,  119,  123,  153,
506
507       123,   20,   15,  131,  131,   12,  119,  119,  119,  142,
508        10,  123,    7,    3,  123,    0,  119,  119,  119,  134,
509         0,  131,  142,  142,  119,    0,    0,  119,  119,  119,
510       119,  119,  130,  130,  130,    0,  134,  134,  134,    0,
511       142,    0,  130,  130,  130,  145,    0,    0,    0,    0,
512         0,    0,    0,  130,  130,  130,  130,  130,  137,  137,
513       137,    0,  145,  145,  145,    0,    0,    0,  137,  137,
514       137,    0,    0,    0,    0,    0,    0,    0,    0,  137,
515       137,  137,  137,  137,  143,    0,    0,    0,    0,    0,
516         0,    0,    0,    0,    0,    0,    0,  143,  143,  143,
517
518         0,    0,    0,    0,    0,    0,    0,  143,  143,  143,
519         0,    0,    0,    0,    0,  143,    0,    0,  143,  143,
520       143,  143,  143,  149,  149,  149,    0,    0,    0,    0,
521         0,    0,    0,  149,  149,  149,    0,    0,    0,    0,
522         0,    0,    0,    0,  149,  149,  149,  149,  149,  157,
523       157,    0,  157,  157,  157,  157,  157,  157,  157,  157,
524       157,  158,  158,    0,  158,    0,  158,  158,  158,  158,
525       158,  158,  158,  159,  159,    0,    0,  159,  159,  159,
526       159,  159,  159,  159,  160,  160,  160,  160,    0,    0,
527         0,    0,  160,  160,  161,  161,  161,    0,    0,    0,
528
529         0,  161,  161,  162,  162,    0,  162,    0,    0,  162,
530       163,  163,    0,  163,    0,    0,  163,  164,  164,    0,
531       164,  164,  164,  164,  164,  164,  164,  164,  164,  165,
532       165,    0,  165,    0,    0,  165,  166,  166,    0,    0,
533         0,    0,    0,  166,  166,  166,  166,  167,  167,  167,
534       167,    0,    0,    0,    0,  167,  167,  168,  168,    0,
535       168,  168,  168,  168,  169,  169,    0,  169,    0,    0,
536       169,  170,  170,    0,  170,  170,  170,  170,  170,  170,
537       170,  170,  170,  171,  171,    0,  171,  171,  171,  171,
538       171,  171,  171,  171,  171,  156,  156,  156,  156,  156,
539
540       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
541       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
542       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
543       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
544       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
545       156,  156,  156
546     } ;
547
548 static yy_state_type yy_last_accepting_state;
549 static char *yy_last_accepting_cpos;
550
551 /* The intent behind this definition is that it'll catch
552  * any uses of REJECT which flex missed.
553  */
554 #define REJECT reject_used_but_not_detected
555 #define yymore() yymore_used_but_not_detected
556 #define YY_MORE_ADJ 0
557 #define YY_RESTORE_YY_MORE_OFFSET
558 char *yytext;
559 #line 1 "xl-lexsp.l"
560 #define INITIAL 0
561 #line 3 "xl-lexsp.l"
562 #define YYSTYPE YSNPTR
563 #include "xl-lex.h"
564 #include "xl-yacc.tab.h"
565 #include "xl-sym.h"
566 #include <string.h>
567
568 extern YSNPTR yylval;
569 extern int MsgToStructFlag;
570 int CurrentInputLineNo=1;
571 int SavedLineNo;
572 int CurrentOutputLineNo=0;
573 char CurrentFileName[2*FILENAMELENGTH];
574 char SavedFileName[2*FILENAMELENGTH];
575 int OutputLineLength=0;
576 extern FILE *outfile;
577
578 extern SYMTABPTR GlobalModuleSearch();
579 extern char token[];
580 int PrevToken=0;
581
582 #define CREATE 1
583 #define NOCREATE 0
584
585 #ifdef yywrap
586 #undef yywrap
587 #endif
588 #line 589 "lex.yy.c"
589
590 /* Macros after this point can all be overridden by user definitions in
591  * section 1.
592  */
593
594 #ifndef YY_SKIP_YYWRAP
595 #ifdef __cplusplus
596 extern "C" int yywrap YY_PROTO(( void ));
597 #else
598 extern int yywrap YY_PROTO(( void ));
599 #endif
600 #endif
601
602 #ifndef YY_NO_UNPUT
603 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
604 #endif
605
606 #ifndef yytext_ptr
607 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
608 #endif
609
610 #ifdef YY_NEED_STRLEN
611 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
612 #endif
613
614 #ifndef YY_NO_INPUT
615 #ifdef __cplusplus
616 static int yyinput YY_PROTO(( void ));
617 #else
618 static int input YY_PROTO(( void ));
619 #endif
620 #endif
621
622 #if YY_STACK_USED
623 static int yy_start_stack_ptr = 0;
624 static int yy_start_stack_depth = 0;
625 static int *yy_start_stack = 0;
626 #ifndef YY_NO_PUSH_STATE
627 static void yy_push_state YY_PROTO(( int new_state ));
628 #endif
629 #ifndef YY_NO_POP_STATE
630 static void yy_pop_state YY_PROTO(( void ));
631 #endif
632 #ifndef YY_NO_TOP_STATE
633 static int yy_top_state YY_PROTO(( void ));
634 #endif
635
636 #else
637 #define YY_NO_PUSH_STATE 1
638 #define YY_NO_POP_STATE 1
639 #define YY_NO_TOP_STATE 1
640 #endif
641
642 #ifdef YY_MALLOC_DECL
643 YY_MALLOC_DECL
644 #else
645 #if __STDC__
646 #ifndef __cplusplus
647 #include <stdlib.h>
648 #endif
649 #else
650 /* Just try to get by without declaring the routines.  This will fail
651  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
652  * or sizeof(void*) != sizeof(int).
653  */
654 #endif
655 #endif
656
657 /* Amount of stuff to slurp up with each read. */
658 #ifndef YY_READ_BUF_SIZE
659 #define YY_READ_BUF_SIZE 8192
660 #endif
661
662 /* Copy whatever the last rule matched to the standard output. */
663
664 #ifndef ECHO
665 /* This used to be an fputs(), but since the string might contain NUL's,
666  * we now use fwrite().
667  */
668 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
669 #endif
670
671 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
672  * is returned in "result".
673  */
674 #ifndef YY_INPUT
675 #define YY_INPUT(buf,result,max_size) \
676         if ( yy_current_buffer->yy_is_interactive ) \
677                 { \
678                 int c = '*', n; \
679                 for ( n = 0; n < max_size && \
680                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
681                         buf[n] = (char) c; \
682                 if ( c == '\n' ) \
683                         buf[n++] = (char) c; \
684                 if ( c == EOF && ferror( yyin ) ) \
685                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
686                 result = n; \
687                 } \
688         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
689                   && ferror( yyin ) ) \
690                 YY_FATAL_ERROR( "input in flex scanner failed" );
691 #endif
692
693 /* No semi-colon after return; correct usage is to write "yyterminate();" -
694  * we don't want an extra ';' after the "return" because that will cause
695  * some compilers to complain about unreachable statements.
696  */
697 #ifndef yyterminate
698 #define yyterminate() return YY_NULL
699 #endif
700
701 /* Number of entries by which start-condition stack grows. */
702 #ifndef YY_START_STACK_INCR
703 #define YY_START_STACK_INCR 25
704 #endif
705
706 /* Report a fatal error. */
707 #ifndef YY_FATAL_ERROR
708 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
709 #endif
710
711 /* Default declaration of generated scanner - a define so the user can
712  * easily add parameters.
713  */
714 #ifndef YY_DECL
715 #define YY_DECL int yylex YY_PROTO(( void ))
716 #endif
717
718 /* Code executed at the beginning of each rule, after yytext and yyleng
719  * have been set up.
720  */
721 #ifndef YY_USER_ACTION
722 #define YY_USER_ACTION
723 #endif
724
725 /* Code executed at the end of each rule. */
726 #ifndef YY_BREAK
727 #define YY_BREAK break;
728 #endif
729
730 #define YY_RULE_SETUP \
731         YY_USER_ACTION
732
733 YY_DECL
734         {
735         register yy_state_type yy_current_state;
736         register char *yy_cp, *yy_bp;
737         register int yy_act;
738
739 #line 43 "xl-lexsp.l"
740
741 #line 742 "lex.yy.c"
742
743         if ( yy_init )
744                 {
745                 yy_init = 0;
746
747 #ifdef YY_USER_INIT
748                 YY_USER_INIT;
749 #endif
750
751                 if ( ! yy_start )
752                         yy_start = 1;   /* first start state */
753
754                 if ( ! yyin )
755                         yyin = stdin;
756
757                 if ( ! yyout )
758                         yyout = stdout;
759
760                 if ( ! yy_current_buffer )
761                         yy_current_buffer =
762                                 yy_create_buffer( yyin, YY_BUF_SIZE );
763
764                 yy_load_buffer_state();
765                 }
766
767         while ( 1 )             /* loops until end-of-file is reached */
768                 {
769                 yy_cp = yy_c_buf_p;
770
771                 /* Support of yytext. */
772                 *yy_cp = yy_hold_char;
773
774                 /* yy_bp points to the position in yy_ch_buf of the start of
775                  * the current run.
776                  */
777                 yy_bp = yy_cp;
778
779                 yy_current_state = yy_start;
780 yy_match:
781                 do
782                         {
783                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
784                         if ( yy_accept[yy_current_state] )
785                                 {
786                                 yy_last_accepting_state = yy_current_state;
787                                 yy_last_accepting_cpos = yy_cp;
788                                 }
789                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
790                                 {
791                                 yy_current_state = (int) yy_def[yy_current_state];
792                                 if ( yy_current_state >= 157 )
793                                         yy_c = yy_meta[(unsigned int) yy_c];
794                                 }
795                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
796                         ++yy_cp;
797                         }
798                 while ( yy_base[yy_current_state] != 596 );
799
800 yy_find_action:
801                 yy_act = yy_accept[yy_current_state];
802                 if ( yy_act == 0 )
803                         { /* have to back up */
804                         yy_cp = yy_last_accepting_cpos;
805                         yy_current_state = yy_last_accepting_state;
806                         yy_act = yy_accept[yy_current_state];
807                         }
808
809                 YY_DO_BEFORE_ACTION;
810
811
812 do_action:      /* This label is used only to access EOF actions. */
813
814
815                 switch ( yy_act )
816         { /* beginning of action switch */
817                         case 0: /* must back up */
818                         /* undo the effects of YY_DO_BEFORE_ACTION */
819                         *yy_cp = yy_hold_char;
820                         yy_cp = yy_last_accepting_cpos;
821                         yy_current_state = yy_last_accepting_state;
822                         goto yy_find_action;
823
824 case 1:
825 YY_RULE_SETUP
826 #line 44 "xl-lexsp.l"
827 { strcpy(token,yytext);return(PrevToken=AT); }
828         YY_BREAK
829 case 2:
830 YY_RULE_SETUP
831 #line 45 "xl-lexsp.l"
832 { mywriteoutput("?",NOCREATE);strcpy(token,yytext);return(PrevToken=QUESTION); }
833         YY_BREAK
834 case 3:
835 YY_RULE_SETUP
836 #line 46 "xl-lexsp.l"
837 { strcpy(token,yytext);return(PrevToken=COLON); }
838         YY_BREAK
839 case 4:
840 YY_RULE_SETUP
841 #line 47 "xl-lexsp.l"
842 { mywriteoutput("|",NOCREATE);strcpy(token,yytext);return(PrevToken=OR); }
843         YY_BREAK
844 case 5:
845 YY_RULE_SETUP
846 #line 48 "xl-lexsp.l"
847 { mywriteoutput("&",NOCREATE);strcpy(token,yytext);return(PrevToken=AND); }
848         YY_BREAK
849 case 6:
850 YY_RULE_SETUP
851 #line 49 "xl-lexsp.l"
852 { mywriteoutput("^",NOCREATE);strcpy(token,yytext);return(PrevToken=HAT); }
853         YY_BREAK
854 case 7:
855 YY_RULE_SETUP
856 #line 50 "xl-lexsp.l"
857 { mywriteoutput("+",NOCREATE);strcpy(token,yytext);return(PrevToken=PLUS); }
858         YY_BREAK
859 case 8:
860 YY_RULE_SETUP
861 #line 51 "xl-lexsp.l"
862 { mywriteoutput("-",NOCREATE);strcpy(token,yytext);return(PrevToken=MINUS); }
863         YY_BREAK
864 case 9:
865 YY_RULE_SETUP
866 #line 52 "xl-lexsp.l"
867 { mywriteoutput("*",NOCREATE);strcpy(token,yytext);return(PrevToken=MULT); }
868         YY_BREAK
869 case 10:
870 YY_RULE_SETUP
871 #line 53 "xl-lexsp.l"
872 { mywriteoutput("/",NOCREATE);strcpy(token,yytext);return(PrevToken=DIV); }
873         YY_BREAK
874 case 11:
875 YY_RULE_SETUP
876 #line 54 "xl-lexsp.l"
877 { mywriteoutput("%",NOCREATE);strcpy(token,yytext);return(PrevToken=MOD); }
878         YY_BREAK
879 case 12:
880 YY_RULE_SETUP
881 #line 55 "xl-lexsp.l"
882 { mywriteoutput("(",NOCREATE);strcpy(token,yytext);return(PrevToken=L_PAREN); }
883         YY_BREAK
884 case 13:
885 YY_RULE_SETUP
886 #line 56 "xl-lexsp.l"
887 { mywriteoutput(")",NOCREATE);strcpy(token,yytext);return(PrevToken=R_PAREN); }
888         YY_BREAK
889 case 14:
890 YY_RULE_SETUP
891 #line 57 "xl-lexsp.l"
892 { mywriteoutput("[",NOCREATE);strcpy(token,yytext);return(PrevToken=L_SQUARE); }
893         YY_BREAK
894 case 15:
895 YY_RULE_SETUP
896 #line 58 "xl-lexsp.l"
897 { mywriteoutput("]",NOCREATE);strcpy(token,yytext);return(PrevToken=R_SQUARE); }
898         YY_BREAK
899 case 16:
900 YY_RULE_SETUP
901 #line 59 "xl-lexsp.l"
902 { mywriteoutput(".",NOCREATE);strcpy(token,yytext);return(PrevToken=DOT); }
903         YY_BREAK
904 case 17:
905 YY_RULE_SETUP
906 #line 60 "xl-lexsp.l"
907 { mywriteoutput("!",NOCREATE);strcpy(token,yytext);return(PrevToken=EXCLAIM); }
908         YY_BREAK
909 case 18:
910 YY_RULE_SETUP
911 #line 61 "xl-lexsp.l"
912 { mywriteoutput("~",NOCREATE);strcpy(token,yytext);return(PrevToken=TILDE); }
913         YY_BREAK
914 case 19:
915 YY_RULE_SETUP
916 #line 62 "xl-lexsp.l"
917 { mywriteoutput("->",NOCREATE);strcpy(token,yytext);return(PrevToken=POINTERREF); }
918         YY_BREAK
919 case 20:
920 YY_RULE_SETUP
921 #line 63 "xl-lexsp.l"
922 { mywriteoutput("++",CREATE);strcpy(token,yytext);return(PrevToken=INCDEC); }
923         YY_BREAK
924 case 21:
925 YY_RULE_SETUP
926 #line 64 "xl-lexsp.l"
927 { mywriteoutput("--",CREATE);strcpy(token,yytext);return(PrevToken=INCDEC); }
928         YY_BREAK
929 case 22:
930 YY_RULE_SETUP
931 #line 65 "xl-lexsp.l"
932 { mywriteoutput("<<",CREATE);strcpy(token,yytext);return(PrevToken=SHIFT); }
933         YY_BREAK
934 case 23:
935 YY_RULE_SETUP
936 #line 66 "xl-lexsp.l"
937 { mywriteoutput(">>",CREATE);strcpy(token,yytext);return(PrevToken=SHIFT); }
938         YY_BREAK
939 case 24:
940 YY_RULE_SETUP
941 #line 67 "xl-lexsp.l"
942 { mywriteoutput("<",CREATE);strcpy(token,yytext);return(PrevToken=COMPARE); }
943         YY_BREAK
944 case 25:
945 YY_RULE_SETUP
946 #line 68 "xl-lexsp.l"
947 { mywriteoutput(">",CREATE);strcpy(token,yytext);return(PrevToken=COMPARE); }
948         YY_BREAK
949 case 26:
950 YY_RULE_SETUP
951 #line 69 "xl-lexsp.l"
952 { mywriteoutput("<=",CREATE);strcpy(token,yytext);return(PrevToken=COMPARE); }
953         YY_BREAK
954 case 27:
955 YY_RULE_SETUP
956 #line 70 "xl-lexsp.l"
957 { mywriteoutput(">=",CREATE);strcpy(token,yytext);return(PrevToken=COMPARE); }
958         YY_BREAK
959 case 28:
960 YY_RULE_SETUP
961 #line 71 "xl-lexsp.l"
962 { mywriteoutput("==",NOCREATE);strcpy(token,yytext);return(PrevToken=EQUALEQUAL); }
963         YY_BREAK
964 case 29:
965 YY_RULE_SETUP
966 #line 72 "xl-lexsp.l"
967 { mywriteoutput("!=",NOCREATE);strcpy(token,yytext);return(PrevToken=NOTEQUAL); }
968         YY_BREAK
969 case 30:
970 YY_RULE_SETUP
971 #line 73 "xl-lexsp.l"
972 { mywriteoutput("&&",NOCREATE);strcpy(token,yytext);return(PrevToken=ANDAND); }
973         YY_BREAK
974 case 31:
975 YY_RULE_SETUP
976 #line 74 "xl-lexsp.l"
977 { mywriteoutput("||",NOCREATE);strcpy(token,yytext);return(PrevToken=OROR); }
978         YY_BREAK
979 case 32:
980 YY_RULE_SETUP
981 #line 75 "xl-lexsp.l"
982 { mywriteoutput("=",NOCREATE);strcpy(token,yytext);return(PrevToken=EQUAL); }
983         YY_BREAK
984 case 33:
985 YY_RULE_SETUP
986 #line 76 "xl-lexsp.l"
987 { mywriteoutput("+=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
988         YY_BREAK
989 case 34:
990 YY_RULE_SETUP
991 #line 77 "xl-lexsp.l"
992 { mywriteoutput("-=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
993         YY_BREAK
994 case 35:
995 YY_RULE_SETUP
996 #line 78 "xl-lexsp.l"
997 { mywriteoutput("*=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
998         YY_BREAK
999 case 36:
1000 YY_RULE_SETUP
1001 #line 79 "xl-lexsp.l"
1002 { mywriteoutput("/=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1003         YY_BREAK
1004 case 37:
1005 YY_RULE_SETUP
1006 #line 80 "xl-lexsp.l"
1007 { mywriteoutput("%=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1008         YY_BREAK
1009 case 38:
1010 YY_RULE_SETUP
1011 #line 81 "xl-lexsp.l"
1012 { mywriteoutput(">>=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1013         YY_BREAK
1014 case 39:
1015 YY_RULE_SETUP
1016 #line 82 "xl-lexsp.l"
1017 { mywriteoutput("<<=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1018         YY_BREAK
1019 case 40:
1020 YY_RULE_SETUP
1021 #line 83 "xl-lexsp.l"
1022 { mywriteoutput("&=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1023         YY_BREAK
1024 case 41:
1025 YY_RULE_SETUP
1026 #line 84 "xl-lexsp.l"
1027 { mywriteoutput("|=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1028         YY_BREAK
1029 case 42:
1030 YY_RULE_SETUP
1031 #line 85 "xl-lexsp.l"
1032 { mywriteoutput("^=",CREATE);strcpy(token,yytext);return(PrevToken=ASGNOP); }
1033         YY_BREAK
1034 case 43:
1035 YY_RULE_SETUP
1036 #line 86 "xl-lexsp.l"
1037 { mywriteoutput(",",NOCREATE);strcpy(token,yytext);return(PrevToken=COMMA); }
1038         YY_BREAK
1039 case 44:
1040 YY_RULE_SETUP
1041 #line 87 "xl-lexsp.l"
1042 { strcpy(token,yytext);return(PrevToken=L_BRACE); }
1043         YY_BREAK
1044 case 45:
1045 YY_RULE_SETUP
1046 #line 88 "xl-lexsp.l"
1047 { strcpy(token,yytext);return(PrevToken=R_BRACE); }
1048         YY_BREAK
1049 case 46:
1050 YY_RULE_SETUP
1051 #line 89 "xl-lexsp.l"
1052 { mywriteoutput(";",NOCREATE);strcpy(token,yytext);return(PrevToken=SEMICOLON); }
1053         YY_BREAK
1054 case 47:
1055 YY_RULE_SETUP
1056 #line 90 "xl-lexsp.l"
1057 { int i,count=0;
1058                 
1059                   strcpy(token,yytext);
1060                   for (i=0;i<yyleng;i++)
1061                         if (yytext[i]=='\n') count++;
1062                   CurrentInputLineNo += count;
1063                   mywriteoutput(",{ ",NOCREATE);return(PrevToken=COMMA_L_BRACE); 
1064                 }
1065         YY_BREAK
1066 case 48:
1067 YY_RULE_SETUP
1068 #line 98 "xl-lexsp.l"
1069 { int i,count=0;
1070                 
1071                   for (i=0;i<yyleng;i++)
1072                         if (yytext[i]=='\n') count++;
1073                   CurrentInputLineNo += count;
1074                   mywriteoutput(",} ",NOCREATE);return(PrevToken=COMMA_R_BRACE); }
1075         YY_BREAK
1076 case 49:
1077 YY_RULE_SETUP
1078 #line 105 "xl-lexsp.l"
1079 { int i=0,j=0;
1080                                                   char temp[FILENAMELENGTH];
1081
1082                                                   while ((yytext[i]<'0')||
1083                                                          (yytext[i]>'9')) 
1084                                                         i++;
1085                                                   while ((yytext[i]>='0') &&
1086                                                          (yytext[i]<='9'))
1087                                                         temp[j++]=yytext[i++];
1088                                                   temp[j]='\0';
1089                                                   CurrentInputLineNo = 
1090                                                         atoi(temp);
1091                                                   while (yytext[i]!='\"')
1092                                                         i++;
1093                                                   yytext[yyleng-1]='\0';
1094                                                   strcpy(CurrentFileName,
1095                                                                 yytext+i+1);
1096                                                 }
1097         YY_BREAK
1098 case 50:
1099 YY_RULE_SETUP
1100 #line 124 "xl-lexsp.l"
1101 { int retvalue;
1102                 
1103                               strcpy(token,yytext);
1104                               yylval=GetYSN();
1105                               yylval->string=MakeString(yytext);
1106                               if ((retvalue=SearchKey(yytext)) == -1)
1107                                   return(PrevToken=TypeToToken(IDType(yytext)));
1108                               else { if (IsKey(yytext))
1109                                         writeoutput(yytext,NOFREE);
1110                                      if (retvalue==0) return(IDENTIFIER);
1111                                      if (MsgToStructFlag && (retvalue==MESSAGE))
1112                                         { retvalue=STRUCT;
1113                                           writeoutput("struct ",NOFREE);
1114                                         }
1115                                      if (retvalue==MAIN)
1116                                         if (PrevToken!=CHARE)
1117                                                 return(PrevToken=IDENTIFIER);
1118                                      return(PrevToken=retvalue);
1119                                    }
1120                             }
1121         YY_BREAK
1122 case 51:
1123 YY_RULE_SETUP
1124 #line 145 "xl-lexsp.l"
1125 { SYMTABPTR worksymtab;
1126                           char *modname,*name,*string;
1127                           int i;char ch;
1128
1129                           strcpy(token,yytext);
1130                           yylval=GetYSN();
1131                           i=0;ch=yytext[0];
1132                           string=GetMem(strlen(yytext));
1133                           while ((ch!=' ')&&(ch!='\t')&&(ch!='\n')&&(ch!=':'))
1134                                 { string[i]=ch;ch=yytext[++i]; }
1135                           string[i]='\0';
1136                           modname=yylval->modstring=MakeString(string);
1137                           while ((ch==' ')||(ch=='\t')||(ch=='\n')||(ch==':'))
1138                                 { if (ch=='\n') CurrentInputLineNo++;
1139                                   ch=yytext[++i]; 
1140                                 }
1141                           name=yylval->string=MakeString(yytext+i);
1142
1143                           worksymtab=GlobalModuleSearch(name,modname);
1144                           if (worksymtab==NULL)
1145                                 { error("Bad Module Reference",EXIT);
1146                                   return(ID_DCOLON_ID);
1147                                 }
1148                           switch (TypeToToken(worksymtab->idtype))
1149                           { case IDENTIFIER : return(ID_DCOLON_ID);
1150                             case TYPE_IDENTIFIER : return(TYPE_IDENTIFIER);
1151                           }
1152                         }
1153         YY_BREAK
1154 case 52:
1155 #line 175 "xl-lexsp.l"
1156 case 53:
1157 #line 176 "xl-lexsp.l"
1158 case 54:
1159 #line 177 "xl-lexsp.l"
1160 case 55:
1161 #line 178 "xl-lexsp.l"
1162 case 56:
1163 #line 179 "xl-lexsp.l"
1164 case 57:
1165 YY_RULE_SETUP
1166 #line 179 "xl-lexsp.l"
1167 { mywriteoutput(yytext,CREATE);
1168                                   strcpy(token,yytext);return(PrevToken=NUMBER);                
1169                                 }
1170         YY_BREAK
1171 case 58:
1172 YY_RULE_SETUP
1173 #line 183 "xl-lexsp.l"
1174 {
1175                                 mywriteoutput(yytext,CREATE);
1176                                   strcpy(token,yytext);return(PrevToken=CHAR_CONST);              }
1177         YY_BREAK
1178 case 59:
1179 YY_RULE_SETUP
1180 #line 187 "xl-lexsp.l"
1181 { mywriteoutput(yytext,CREATE);
1182                                   strcpy(token,yytext);return(PrevToken=STRING);
1183                                 }
1184         YY_BREAK
1185 case 60:
1186 YY_RULE_SETUP
1187 #line 191 "xl-lexsp.l"
1188 { writeoutput(yytext,NOFREE); }        /* Skip whitespace...*/
1189         YY_BREAK
1190 case 61:
1191 YY_RULE_SETUP
1192 #line 192 "xl-lexsp.l"
1193 { CurrentInputLineNo++; WriteReturn(); 
1194                 /*printf("%d Line\n",yylineno);*/
1195                 }
1196         YY_BREAK
1197 case 62:
1198 YY_RULE_SETUP
1199 #line 196 "xl-lexsp.l"
1200 {writeoutput(yytext,NOFREE);
1201                                         CurrentInputLineNo++;
1202                                         WriteReturn();}
1203         YY_BREAK
1204 case 63:
1205 YY_RULE_SETUP
1206 #line 200 "xl-lexsp.l"
1207 {writeoutput(yytext,NOFREE);
1208                                         CurrentInputLineNo++;
1209                                         WriteReturn();}
1210         YY_BREAK
1211 case 64:
1212 YY_RULE_SETUP
1213 #line 204 "xl-lexsp.l"
1214 { error("Lexical Oddity",EXIT); }
1215         YY_BREAK
1216 case 65:
1217 YY_RULE_SETUP
1218 #line 206 "xl-lexsp.l"
1219 ECHO;
1220         YY_BREAK
1221 #line 1222 "lex.yy.c"
1222 case YY_STATE_EOF(INITIAL):
1223         yyterminate();
1224
1225         case YY_END_OF_BUFFER:
1226                 {
1227                 /* Amount of text matched not including the EOB char. */
1228                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1229
1230                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1231                 *yy_cp = yy_hold_char;
1232                 YY_RESTORE_YY_MORE_OFFSET
1233
1234                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1235                         {
1236                         /* We're scanning a new file or input source.  It's
1237                          * possible that this happened because the user
1238                          * just pointed yyin at a new source and called
1239                          * yylex().  If so, then we have to assure
1240                          * consistency between yy_current_buffer and our
1241                          * globals.  Here is the right place to do so, because
1242                          * this is the first action (other than possibly a
1243                          * back-up) that will match for the new input source.
1244                          */
1245                         yy_n_chars = yy_current_buffer->yy_n_chars;
1246                         yy_current_buffer->yy_input_file = yyin;
1247                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1248                         }
1249
1250                 /* Note that here we test for yy_c_buf_p "<=" to the position
1251                  * of the first EOB in the buffer, since yy_c_buf_p will
1252                  * already have been incremented past the NUL character
1253                  * (since all states make transitions on EOB to the
1254                  * end-of-buffer state).  Contrast this with the test
1255                  * in input().
1256                  */
1257                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1258                         { /* This was really a NUL. */
1259                         yy_state_type yy_next_state;
1260
1261                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1262
1263                         yy_current_state = yy_get_previous_state();
1264
1265                         /* Okay, we're now positioned to make the NUL
1266                          * transition.  We couldn't have
1267                          * yy_get_previous_state() go ahead and do it
1268                          * for us because it doesn't know how to deal
1269                          * with the possibility of jamming (and we don't
1270                          * want to build jamming into it because then it
1271                          * will run more slowly).
1272                          */
1273
1274                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1275
1276                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1277
1278                         if ( yy_next_state )
1279                                 {
1280                                 /* Consume the NUL. */
1281                                 yy_cp = ++yy_c_buf_p;
1282                                 yy_current_state = yy_next_state;
1283                                 goto yy_match;
1284                                 }
1285
1286                         else
1287                                 {
1288                                 yy_cp = yy_c_buf_p;
1289                                 goto yy_find_action;
1290                                 }
1291                         }
1292
1293                 else switch ( yy_get_next_buffer() )
1294                         {
1295                         case EOB_ACT_END_OF_FILE:
1296                                 {
1297                                 yy_did_buffer_switch_on_eof = 0;
1298
1299                                 if ( yywrap() )
1300                                         {
1301                                         /* Note: because we've taken care in
1302                                          * yy_get_next_buffer() to have set up
1303                                          * yytext, we can now set up
1304                                          * yy_c_buf_p so that if some total
1305                                          * hoser (like flex itself) wants to
1306                                          * call the scanner after we return the
1307                                          * YY_NULL, it'll still work - another
1308                                          * YY_NULL will get returned.
1309                                          */
1310                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1311
1312                                         yy_act = YY_STATE_EOF(YY_START);
1313                                         goto do_action;
1314                                         }
1315
1316                                 else
1317                                         {
1318                                         if ( ! yy_did_buffer_switch_on_eof )
1319                                                 YY_NEW_FILE;
1320                                         }
1321                                 break;
1322                                 }
1323
1324                         case EOB_ACT_CONTINUE_SCAN:
1325                                 yy_c_buf_p =
1326                                         yytext_ptr + yy_amount_of_matched_text;
1327
1328                                 yy_current_state = yy_get_previous_state();
1329
1330                                 yy_cp = yy_c_buf_p;
1331                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1332                                 goto yy_match;
1333
1334                         case EOB_ACT_LAST_MATCH:
1335                                 yy_c_buf_p =
1336                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1337
1338                                 yy_current_state = yy_get_previous_state();
1339
1340                                 yy_cp = yy_c_buf_p;
1341                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1342                                 goto yy_find_action;
1343                         }
1344                 break;
1345                 }
1346
1347         default:
1348                 YY_FATAL_ERROR(
1349                         "fatal flex scanner internal error--no action found" );
1350         } /* end of action switch */
1351                 } /* end of scanning one token */
1352         } /* end of yylex */
1353
1354
1355 /* yy_get_next_buffer - try to read in a new buffer
1356  *
1357  * Returns a code representing an action:
1358  *      EOB_ACT_LAST_MATCH -
1359  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1360  *      EOB_ACT_END_OF_FILE - end of file
1361  */
1362
1363 static int yy_get_next_buffer()
1364         {
1365         register char *dest = yy_current_buffer->yy_ch_buf;
1366         register char *source = yytext_ptr;
1367         register int number_to_move, i;
1368         int ret_val;
1369
1370         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1371                 YY_FATAL_ERROR(
1372                 "fatal flex scanner internal error--end of buffer missed" );
1373
1374         if ( yy_current_buffer->yy_fill_buffer == 0 )
1375                 { /* Don't try to fill the buffer, so this is an EOF. */
1376                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1377                         {
1378                         /* We matched a single character, the EOB, so
1379                          * treat this as a final EOF.
1380                          */
1381                         return EOB_ACT_END_OF_FILE;
1382                         }
1383
1384                 else
1385                         {
1386                         /* We matched some text prior to the EOB, first
1387                          * process it.
1388                          */
1389                         return EOB_ACT_LAST_MATCH;
1390                         }
1391                 }
1392
1393         /* Try to read more data. */
1394
1395         /* First move last chars to start of buffer. */
1396         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1397
1398         for ( i = 0; i < number_to_move; ++i )
1399                 *(dest++) = *(source++);
1400
1401         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1402                 /* don't do the read, it's not guaranteed to return an EOF,
1403                  * just force an EOF
1404                  */
1405                 yy_n_chars = 0;
1406
1407         else
1408                 {
1409                 int num_to_read =
1410                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1411
1412                 while ( num_to_read <= 0 )
1413                         { /* Not enough room in the buffer - grow it. */
1414 #ifdef YY_USES_REJECT
1415                         YY_FATAL_ERROR(
1416 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1417 #else
1418
1419                         /* just a shorter name for the current buffer */
1420                         YY_BUFFER_STATE b = yy_current_buffer;
1421
1422                         int yy_c_buf_p_offset =
1423                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1424
1425                         if ( b->yy_is_our_buffer )
1426                                 {
1427                                 int new_size = b->yy_buf_size * 2;
1428
1429                                 if ( new_size <= 0 )
1430                                         b->yy_buf_size += b->yy_buf_size / 8;
1431                                 else
1432                                         b->yy_buf_size *= 2;
1433
1434                                 b->yy_ch_buf = (char *)
1435                                         /* Include room in for 2 EOB chars. */
1436                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1437                                                          b->yy_buf_size + 2 );
1438                                 }
1439                         else
1440                                 /* Can't grow it, we don't own it. */
1441                                 b->yy_ch_buf = 0;
1442
1443                         if ( ! b->yy_ch_buf )
1444                                 YY_FATAL_ERROR(
1445                                 "fatal error - scanner input buffer overflow" );
1446
1447                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1448
1449                         num_to_read = yy_current_buffer->yy_buf_size -
1450                                                 number_to_move - 1;
1451 #endif
1452                         }
1453
1454                 if ( num_to_read > YY_READ_BUF_SIZE )
1455                         num_to_read = YY_READ_BUF_SIZE;
1456
1457                 /* Read in more data. */
1458                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1459                         yy_n_chars, num_to_read );
1460                 }
1461
1462         if ( yy_n_chars == 0 )
1463                 {
1464                 if ( number_to_move == YY_MORE_ADJ )
1465                         {
1466                         ret_val = EOB_ACT_END_OF_FILE;
1467                         yyrestart( yyin );
1468                         }
1469
1470                 else
1471                         {
1472                         ret_val = EOB_ACT_LAST_MATCH;
1473                         yy_current_buffer->yy_buffer_status =
1474                                 YY_BUFFER_EOF_PENDING;
1475                         }
1476                 }
1477
1478         else
1479                 ret_val = EOB_ACT_CONTINUE_SCAN;
1480
1481         yy_n_chars += number_to_move;
1482         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1483         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1484
1485         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1486
1487         return ret_val;
1488         }
1489
1490
1491 /* yy_get_previous_state - get the state just before the EOB char was reached */
1492
1493 static yy_state_type yy_get_previous_state()
1494         {
1495         register yy_state_type yy_current_state;
1496         register char *yy_cp;
1497
1498         yy_current_state = yy_start;
1499
1500         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1501                 {
1502                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1503                 if ( yy_accept[yy_current_state] )
1504                         {
1505                         yy_last_accepting_state = yy_current_state;
1506                         yy_last_accepting_cpos = yy_cp;
1507                         }
1508                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1509                         {
1510                         yy_current_state = (int) yy_def[yy_current_state];
1511                         if ( yy_current_state >= 157 )
1512                                 yy_c = yy_meta[(unsigned int) yy_c];
1513                         }
1514                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1515                 }
1516
1517         return yy_current_state;
1518         }
1519
1520
1521 /* yy_try_NUL_trans - try to make a transition on the NUL character
1522  *
1523  * synopsis
1524  *      next_state = yy_try_NUL_trans( current_state );
1525  */
1526
1527 #ifdef YY_USE_PROTOS
1528 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1529 #else
1530 static yy_state_type yy_try_NUL_trans( yy_current_state )
1531 yy_state_type yy_current_state;
1532 #endif
1533         {
1534         register int yy_is_jam;
1535         register char *yy_cp = yy_c_buf_p;
1536
1537         register YY_CHAR yy_c = 1;
1538         if ( yy_accept[yy_current_state] )
1539                 {
1540                 yy_last_accepting_state = yy_current_state;
1541                 yy_last_accepting_cpos = yy_cp;
1542                 }
1543         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1544                 {
1545                 yy_current_state = (int) yy_def[yy_current_state];
1546                 if ( yy_current_state >= 157 )
1547                         yy_c = yy_meta[(unsigned int) yy_c];
1548                 }
1549         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1550         yy_is_jam = (yy_current_state == 156);
1551
1552         return yy_is_jam ? 0 : yy_current_state;
1553         }
1554
1555
1556 #ifndef YY_NO_UNPUT
1557 #ifdef YY_USE_PROTOS
1558 static void yyunput( int c, register char *yy_bp )
1559 #else
1560 static void yyunput( c, yy_bp )
1561 int c;
1562 register char *yy_bp;
1563 #endif
1564         {
1565         register char *yy_cp = yy_c_buf_p;
1566
1567         /* undo effects of setting up yytext */
1568         *yy_cp = yy_hold_char;
1569
1570         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1571                 { /* need to shift things up to make room */
1572                 /* +2 for EOB chars. */
1573                 register int number_to_move = yy_n_chars + 2;
1574                 register char *dest = &yy_current_buffer->yy_ch_buf[
1575                                         yy_current_buffer->yy_buf_size + 2];
1576                 register char *source =
1577                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1578
1579                 while ( source > yy_current_buffer->yy_ch_buf )
1580                         *--dest = *--source;
1581
1582                 yy_cp += (int) (dest - source);
1583                 yy_bp += (int) (dest - source);
1584                 yy_n_chars = yy_current_buffer->yy_buf_size;
1585
1586                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1587                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1588                 }
1589
1590         *--yy_cp = (char) c;
1591
1592
1593         yytext_ptr = yy_bp;
1594         yy_hold_char = *yy_cp;
1595         yy_c_buf_p = yy_cp;
1596         }
1597 #endif  /* ifndef YY_NO_UNPUT */
1598
1599
1600 #ifdef __cplusplus
1601 static int yyinput()
1602 #else
1603 static int input()
1604 #endif
1605         {
1606         int c;
1607
1608         *yy_c_buf_p = yy_hold_char;
1609
1610         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1611                 {
1612                 /* yy_c_buf_p now points to the character we want to return.
1613                  * If this occurs *before* the EOB characters, then it's a
1614                  * valid NUL; if not, then we've hit the end of the buffer.
1615                  */
1616                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1617                         /* This was really a NUL. */
1618                         *yy_c_buf_p = '\0';
1619
1620                 else
1621                         { /* need more input */
1622                         int offset = yy_c_buf_p - yytext_ptr;
1623                         ++yy_c_buf_p;
1624
1625                         switch ( yy_get_next_buffer() )
1626                                 {
1627                                 case EOB_ACT_END_OF_FILE:
1628                                         {
1629                                         if ( yywrap() )
1630                                                 {
1631                                                 yy_c_buf_p = yytext_ptr + offset;
1632                                                 return EOF;
1633                                                 }
1634
1635                                         if ( ! yy_did_buffer_switch_on_eof )
1636                                                 YY_NEW_FILE;
1637 #ifdef __cplusplus
1638                                         return yyinput();
1639 #else
1640                                         return input();
1641 #endif
1642                                         }
1643
1644                                 case EOB_ACT_CONTINUE_SCAN:
1645                                         yy_c_buf_p = yytext_ptr + offset;
1646                                         break;
1647
1648                                 case EOB_ACT_LAST_MATCH:
1649 #ifdef __cplusplus
1650                                         YY_FATAL_ERROR(
1651                                         "unexpected last match in yyinput()" );
1652 #else
1653                                         YY_FATAL_ERROR(
1654                                         "unexpected last match in input()" );
1655 #endif
1656                                 }
1657                         }
1658                 }
1659
1660         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1661         *yy_c_buf_p = '\0';     /* preserve yytext */
1662         yy_hold_char = *++yy_c_buf_p;
1663
1664
1665         return c;
1666         }
1667
1668
1669 #ifdef YY_USE_PROTOS
1670 void yyrestart( FILE *input_file )
1671 #else
1672 void yyrestart( input_file )
1673 FILE *input_file;
1674 #endif
1675         {
1676         if ( ! yy_current_buffer )
1677                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1678
1679         yy_init_buffer( yy_current_buffer, input_file );
1680         yy_load_buffer_state();
1681         }
1682
1683
1684 #ifdef YY_USE_PROTOS
1685 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1686 #else
1687 void yy_switch_to_buffer( new_buffer )
1688 YY_BUFFER_STATE new_buffer;
1689 #endif
1690         {
1691         if ( yy_current_buffer == new_buffer )
1692                 return;
1693
1694         if ( yy_current_buffer )
1695                 {
1696                 /* Flush out information for old buffer. */
1697                 *yy_c_buf_p = yy_hold_char;
1698                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1699                 yy_current_buffer->yy_n_chars = yy_n_chars;
1700                 }
1701
1702         yy_current_buffer = new_buffer;
1703         yy_load_buffer_state();
1704
1705         /* We don't actually know whether we did this switch during
1706          * EOF (yywrap()) processing, but the only time this flag
1707          * is looked at is after yywrap() is called, so it's safe
1708          * to go ahead and always set it.
1709          */
1710         yy_did_buffer_switch_on_eof = 1;
1711         }
1712
1713
1714 #ifdef YY_USE_PROTOS
1715 void yy_load_buffer_state( void )
1716 #else
1717 void yy_load_buffer_state()
1718 #endif
1719         {
1720         yy_n_chars = yy_current_buffer->yy_n_chars;
1721         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1722         yyin = yy_current_buffer->yy_input_file;
1723         yy_hold_char = *yy_c_buf_p;
1724         }
1725
1726
1727 #ifdef YY_USE_PROTOS
1728 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1729 #else
1730 YY_BUFFER_STATE yy_create_buffer( file, size )
1731 FILE *file;
1732 int size;
1733 #endif
1734         {
1735         YY_BUFFER_STATE b;
1736
1737         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1738         if ( ! b )
1739                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1740
1741         b->yy_buf_size = size;
1742
1743         /* yy_ch_buf has to be 2 characters longer than the size given because
1744          * we need to put in 2 end-of-buffer characters.
1745          */
1746         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1747         if ( ! b->yy_ch_buf )
1748                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1749
1750         b->yy_is_our_buffer = 1;
1751
1752         yy_init_buffer( b, file );
1753
1754         return b;
1755         }
1756
1757
1758 #ifdef YY_USE_PROTOS
1759 void yy_delete_buffer( YY_BUFFER_STATE b )
1760 #else
1761 void yy_delete_buffer( b )
1762 YY_BUFFER_STATE b;
1763 #endif
1764         {
1765         if ( ! b )
1766                 return;
1767
1768         if ( b == yy_current_buffer )
1769                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1770
1771         if ( b->yy_is_our_buffer )
1772                 yy_flex_free( (void *) b->yy_ch_buf );
1773
1774         yy_flex_free( (void *) b );
1775         }
1776
1777
1778 #ifndef YY_ALWAYS_INTERACTIVE
1779 #ifndef YY_NEVER_INTERACTIVE
1780 extern int isatty YY_PROTO(( int ));
1781 #endif
1782 #endif
1783
1784 #ifdef YY_USE_PROTOS
1785 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1786 #else
1787 void yy_init_buffer( b, file )
1788 YY_BUFFER_STATE b;
1789 FILE *file;
1790 #endif
1791
1792
1793         {
1794         yy_flush_buffer( b );
1795
1796         b->yy_input_file = file;
1797         b->yy_fill_buffer = 1;
1798
1799 #if YY_ALWAYS_INTERACTIVE
1800         b->yy_is_interactive = 1;
1801 #else
1802 #if YY_NEVER_INTERACTIVE
1803         b->yy_is_interactive = 0;
1804 #else
1805         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1806 #endif
1807 #endif
1808         }
1809
1810
1811 #ifdef YY_USE_PROTOS
1812 void yy_flush_buffer( YY_BUFFER_STATE b )
1813 #else
1814 void yy_flush_buffer( b )
1815 YY_BUFFER_STATE b;
1816 #endif
1817
1818         {
1819         b->yy_n_chars = 0;
1820
1821         /* We always need two end-of-buffer characters.  The first causes
1822          * a transition to the end-of-buffer state.  The second causes
1823          * a jam in that state.
1824          */
1825         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1826         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1827
1828         b->yy_buf_pos = &b->yy_ch_buf[0];
1829
1830         b->yy_at_bol = 1;
1831         b->yy_buffer_status = YY_BUFFER_NEW;
1832
1833         if ( b == yy_current_buffer )
1834                 yy_load_buffer_state();
1835         }
1836
1837
1838 #ifndef YY_NO_SCAN_BUFFER
1839 #ifdef YY_USE_PROTOS
1840 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1841 #else
1842 YY_BUFFER_STATE yy_scan_buffer( base, size )
1843 char *base;
1844 yy_size_t size;
1845 #endif
1846         {
1847         YY_BUFFER_STATE b;
1848
1849         if ( size < 2 ||
1850              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1851              base[size-1] != YY_END_OF_BUFFER_CHAR )
1852                 /* They forgot to leave room for the EOB's. */
1853                 return 0;
1854
1855         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1856         if ( ! b )
1857                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1858
1859         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1860         b->yy_buf_pos = b->yy_ch_buf = base;
1861         b->yy_is_our_buffer = 0;
1862         b->yy_input_file = 0;
1863         b->yy_n_chars = b->yy_buf_size;
1864         b->yy_is_interactive = 0;
1865         b->yy_at_bol = 1;
1866         b->yy_fill_buffer = 0;
1867         b->yy_buffer_status = YY_BUFFER_NEW;
1868
1869         yy_switch_to_buffer( b );
1870
1871         return b;
1872         }
1873 #endif
1874
1875
1876 #ifndef YY_NO_SCAN_STRING
1877 #ifdef YY_USE_PROTOS
1878 YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1879 #else
1880 YY_BUFFER_STATE yy_scan_string( str )
1881 yyconst char *str;
1882 #endif
1883         {
1884         int len;
1885         for ( len = 0; str[len]; ++len )
1886                 ;
1887
1888         return yy_scan_bytes( str, len );
1889         }
1890 #endif
1891
1892
1893 #ifndef YY_NO_SCAN_BYTES
1894 #ifdef YY_USE_PROTOS
1895 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1896 #else
1897 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1898 yyconst char *bytes;
1899 int len;
1900 #endif
1901         {
1902         YY_BUFFER_STATE b;
1903         char *buf;
1904         yy_size_t n;
1905         int i;
1906
1907         /* Get memory for full buffer, including space for trailing EOB's. */
1908         n = len + 2;
1909         buf = (char *) yy_flex_alloc( n );
1910         if ( ! buf )
1911                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1912
1913         for ( i = 0; i < len; ++i )
1914                 buf[i] = bytes[i];
1915
1916         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1917
1918         b = yy_scan_buffer( buf, n );
1919         if ( ! b )
1920                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1921
1922         /* It's okay to grow etc. this buffer, and we should throw it
1923          * away when we're done.
1924          */
1925         b->yy_is_our_buffer = 1;
1926
1927         return b;
1928         }
1929 #endif
1930
1931
1932 #ifndef YY_NO_PUSH_STATE
1933 #ifdef YY_USE_PROTOS
1934 static void yy_push_state( int new_state )
1935 #else
1936 static void yy_push_state( new_state )
1937 int new_state;
1938 #endif
1939         {
1940         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1941                 {
1942                 yy_size_t new_size;
1943
1944                 yy_start_stack_depth += YY_START_STACK_INCR;
1945                 new_size = yy_start_stack_depth * sizeof( int );
1946
1947                 if ( ! yy_start_stack )
1948                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1949
1950                 else
1951                         yy_start_stack = (int *) yy_flex_realloc(
1952                                         (void *) yy_start_stack, new_size );
1953
1954                 if ( ! yy_start_stack )
1955                         YY_FATAL_ERROR(
1956                         "out of memory expanding start-condition stack" );
1957                 }
1958
1959         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1960
1961         BEGIN(new_state);
1962         }
1963 #endif
1964
1965
1966 #ifndef YY_NO_POP_STATE
1967 static void yy_pop_state()
1968         {
1969         if ( --yy_start_stack_ptr < 0 )
1970                 YY_FATAL_ERROR( "start-condition stack underflow" );
1971
1972         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1973         }
1974 #endif
1975
1976
1977 #ifndef YY_NO_TOP_STATE
1978 static int yy_top_state()
1979         {
1980         return yy_start_stack[yy_start_stack_ptr - 1];
1981         }
1982 #endif
1983
1984 #ifndef YY_EXIT_FAILURE
1985 #define YY_EXIT_FAILURE 2
1986 #endif
1987
1988 #ifdef YY_USE_PROTOS
1989 static void yy_fatal_error( yyconst char msg[] )
1990 #else
1991 static void yy_fatal_error( msg )
1992 char msg[];
1993 #endif
1994         {
1995         (void) fprintf( stderr, "%s\n", msg );
1996         exit( YY_EXIT_FAILURE );
1997         }
1998
1999
2000
2001 /* Redefine yyless() so it works in section 3 code. */
2002
2003 #undef yyless
2004 #define yyless(n) \
2005         do \
2006                 { \
2007                 /* Undo effects of setting up yytext. */ \
2008                 yytext[yyleng] = yy_hold_char; \
2009                 yy_c_buf_p = yytext + n; \
2010                 yy_hold_char = *yy_c_buf_p; \
2011                 *yy_c_buf_p = '\0'; \
2012                 yyleng = n; \
2013                 } \
2014         while ( 0 )
2015
2016
2017 /* Internal utility routines. */
2018
2019 #ifndef yytext_ptr
2020 #ifdef YY_USE_PROTOS
2021 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2022 #else
2023 static void yy_flex_strncpy( s1, s2, n )
2024 char *s1;
2025 yyconst char *s2;
2026 int n;
2027 #endif
2028         {
2029         register int i;
2030         for ( i = 0; i < n; ++i )
2031                 s1[i] = s2[i];
2032         }
2033 #endif
2034
2035 #ifdef YY_NEED_STRLEN
2036 #ifdef YY_USE_PROTOS
2037 static int yy_flex_strlen( yyconst char *s )
2038 #else
2039 static int yy_flex_strlen( s )
2040 yyconst char *s;
2041 #endif
2042         {
2043         register int n;
2044         for ( n = 0; s[n]; ++n )
2045                 ;
2046
2047         return n;
2048         }
2049 #endif
2050
2051
2052 #ifdef YY_USE_PROTOS
2053 static void *yy_flex_alloc( yy_size_t size )
2054 #else
2055 static void *yy_flex_alloc( size )
2056 yy_size_t size;
2057 #endif
2058         {
2059         return (void *) malloc( size );
2060         }
2061
2062 #ifdef YY_USE_PROTOS
2063 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2064 #else
2065 static void *yy_flex_realloc( ptr, size )
2066 void *ptr;
2067 yy_size_t size;
2068 #endif
2069         {
2070         /* The cast to (char *) in the following accommodates both
2071          * implementations that use char* generic pointers, and those
2072          * that use void* generic pointers.  It works with the latter
2073          * because both ANSI C and C++ allow castless assignment from
2074          * any pointer type to void*, and deal with argument conversions
2075          * as though doing an assignment.
2076          */
2077         return (void *) realloc( (char *) ptr, size );
2078         }
2079
2080 #ifdef YY_USE_PROTOS
2081 static void yy_flex_free( void *ptr )
2082 #else
2083 static void yy_flex_free( ptr )
2084 void *ptr;
2085 #endif
2086         {
2087         free( ptr );
2088         }
2089
2090 #if YY_MAIN
2091 int main()
2092         {
2093         yylex();
2094         return 0;
2095         }
2096 #endif
2097 #line 206 "xl-lexsp.l"
2098
2099
2100 yywrap(){ PrevToken=0; return(1); }
2101
2102 mywriteoutput(string,flag)
2103 char *string;
2104 int flag;
2105 { if (!flag) return;
2106   yylval=GetYSN();
2107   yylval->string=MakeString(string);
2108 }
2109
2110 TypeToToken(type)
2111 int type;
2112 { switch (type)
2113   { case TYPENAME :
2114     case MESSAGENAME : return(TYPE_IDENTIFIER);
2115     case MODULENAME :
2116     case CHARENAME  :
2117     case BOCNAME    :
2118     case ENTRYNAME  :
2119     default    : return(IDENTIFIER);
2120   }
2121 }