Initial revision
[charm.git] / src / xlat / xl-sfspec.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 11
286 #define YY_END_OF_BUFFER 12
287 static yyconst short int yy_accept[108] =
288     {   0,
289         0,    0,   12,   10,   11,   10,   10,   10,   10,   10,
290        10,    0,    8,    0,    0,    0,    0,    0,    0,    0,
291         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
292         0,    0,    0,    0,    0,    0,    9,    0,    0,    0,
293         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
294         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
295         0,    0,    0,    0,    0,    0,    0,    0,    3,    0,
296         0,    0,    0,    2,    0,    0,    0,    0,    0,    0,
297         0,    0,    4,    0,    0,    0,    1,    0,    0,    0,
298         0,    0,    0,    0,    0,    5,    0,    0,    0,    0,
299
300         0,    0,    6,    0,    0,    7,    0
301     } ;
302
303 static yyconst int yy_ec[256] =
304     {   0,
305         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
306         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
307         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
308         1,    2,    1,    4,    5,    1,    1,    1,    1,    6,
309         1,    1,    1,    1,    1,    1,    1,    7,    7,    7,
310         7,    7,    7,    7,    7,    7,    7,    1,    1,    1,
311         1,    1,    1,    1,    1,    8,    9,   10,    1,    1,
312         1,    1,   11,    1,    1,    1,   12,   13,    1,    1,
313         1,    1,   14,    1,    1,    1,    1,    1,    1,    1,
314         1,    1,    1,    1,    1,    1,   15,    1,   16,   17,
315
316        18,    1,   19,   20,   21,    1,    1,   21,   22,   23,
317        24,    1,    1,   25,   26,   27,   28,    1,    1,    1,
318        29,    1,    1,    1,    1,    1,    1,    1,    1,    1,
319         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
321         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
322         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
323         1,    1,    1,    1,    1,    1,    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
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         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
332         1,    1,    1,    1,    1
333     } ;
334
335 static yyconst int yy_meta[30] =
336     {   0,
337         1,    2,    3,    1,    1,    1,    2,    1,    1,    1,
338         1,    1,    1,    1,    1,    1,    1,    2,    1,    1,
339         2,    1,    2,    1,    1,    1,    1,    1,    1
340     } ;
341
342 static yyconst short int yy_base[111] =
343     {   0,
344         0,   12,  158,  159,  159,    0,  132,  131,  133,  125,
345       135,   11,   23,   26,  128,  133,  128,  141,  125,    2,
346       143,   27,  131,  130,  130,    7,  126,  138,   33,  124,
347       113,  121,  122,  122,  124,   34,   12,  119,  116,  110,
348       119,  108,  104,  114,   34,  111,   99,  110,  106,   98,
349        99,  102,  109,   98,   99,  110,   90,  100,  100,   88,
350        42,  102,   87,   99,   44,   85,   90,   49,  159,   98,
351        92,   80,   51,  159,   87,   96,   56,   80,   83,   58,
352        76,   63,  159,   84,   91,   65,  159,   83,   71,   59,
353        54,   70,   55,   47,   72,  159,   33,   29,   23,   77,
354
355         2,   79,  159,   84,   86,  159,  159,   92,    8,   95
356     } ;
357
358 static yyconst short int yy_def[111] =
359     {   0,
360       108,  108,  107,  107,  107,  109,  107,  107,  107,  107,
361       107,  109,  107,  107,  107,  107,  107,  107,  107,  107,
362       110,  107,  107,  107,  107,  107,  107,  110,  110,  107,
363       107,  107,  107,  107,  107,  110,  110,  107,  107,  107,
364       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
365       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
366       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
367       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
368       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
369       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
370
371       107,  107,  107,  107,  107,  107,    0,  107,  107,  107
372     } ;
373
374 static yyconst short int yy_nxt[189] =
375     {   0,
376       107,   12,    5,   20,    6,   21,   13,    7,    8,   14,
377         9,   10,   12,   11,    5,   29,    6,   13,   37,    7,
378         8,  104,    9,   10,   20,   11,   21,   22,   22,   13,
379        33,   34,   13,   13,   36,   36,   29,   29,  101,   37,
380        37,   51,   52,   68,   68,   73,   73,   69,  100,   74,
381        68,   68,   73,   73,   69,   99,   74,   82,   82,   86,
382        86,   83,   98,   87,   82,   82,   86,   86,   83,   97,
383        87,   95,   95,   95,   95,   96,   94,   96,  102,  102,
384       102,  102,  103,   93,  103,  105,  105,  105,  105,  106,
385        92,  106,    4,    4,    4,   28,   28,   91,   90,   89,
386
387        88,   85,   84,   81,   80,   79,   78,   77,   76,   75,
388        72,   71,   70,   67,   66,   65,   64,   63,   62,   61,
389        60,   59,   58,   57,   56,   55,   54,   53,   50,   49,
390        48,   47,   46,   45,   44,   43,   42,   41,   40,   39,
391        38,   29,   35,   32,   31,   30,   29,   27,   26,   25,
392        24,   23,   19,   18,   17,   16,   15,  107,    3,  107,
393       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
394       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
395       107,  107,  107,  107,  107,  107,  107,  107
396     } ;
397
398 static yyconst short int yy_chk[189] =
399     {   0,
400         0,    6,    1,   20,    1,   20,    6,    1,    1,  109,
401         1,    1,   12,    1,    2,   37,    2,   12,   37,    2,
402         2,  101,    2,    2,   13,    2,   13,   14,   22,   13,
403        26,   26,   14,   22,   29,   36,   29,   36,   99,   29,
404        36,   45,   45,   61,   61,   65,   65,   61,   98,   65,
405        68,   68,   73,   73,   68,   97,   73,   77,   77,   80,
406        80,   77,   94,   80,   82,   82,   86,   86,   82,   93,
407        86,   92,   92,   95,   95,   92,   91,   95,  100,  100,
408       102,  102,  100,   90,  102,  104,  104,  105,  105,  104,
409        89,  105,  108,  108,  108,  110,  110,   88,   85,   84,
410
411        81,   79,   78,   76,   75,   72,   71,   70,   67,   66,
412        64,   63,   62,   60,   59,   58,   57,   56,   55,   54,
413        53,   52,   51,   50,   49,   48,   47,   46,   44,   43,
414        42,   41,   40,   39,   38,   35,   34,   33,   32,   31,
415        30,   28,   27,   25,   24,   23,   21,   19,   18,   17,
416        16,   15,   11,   10,    9,    8,    7,    3,  107,  107,
417       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
418       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
419       107,  107,  107,  107,  107,  107,  107,  107
420     } ;
421
422 static yy_state_type yy_last_accepting_state;
423 static char *yy_last_accepting_cpos;
424
425 /* The intent behind this definition is that it'll catch
426  * any uses of REJECT which flex missed.
427  */
428 #define REJECT reject_used_but_not_detected
429 #define yymore() yymore_used_but_not_detected
430 #define YY_MORE_ADJ 0
431 #define YY_RESTORE_YY_MORE_OFFSET
432 char *yytext;
433 #line 1 "xl-sfspec.l"
434 #define INITIAL 0
435 #line 2 "xl-sfspec.l"
436 #include <string.h>
437 int currentline=1;
438
439 #ifdef yywrap
440 #undef yywrap
441 #endif
442
443 /* Macros after this point can all be overridden by user definitions in
444  * section 1.
445  */
446
447 #ifndef YY_SKIP_YYWRAP
448 #ifdef __cplusplus
449 extern "C" int yywrap YY_PROTO(( void ));
450 #else
451 extern int yywrap YY_PROTO(( void ));
452 #endif
453 #endif
454
455 #ifndef YY_NO_UNPUT
456 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
457 #endif
458
459 #ifndef yytext_ptr
460 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
461 #endif
462
463 #ifdef YY_NEED_STRLEN
464 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
465 #endif
466
467 #ifndef YY_NO_INPUT
468 #ifdef __cplusplus
469 static int yyinput YY_PROTO(( void ));
470 #else
471 static int input YY_PROTO(( void ));
472 #endif
473 #endif
474
475 #if YY_STACK_USED
476 static int yy_start_stack_ptr = 0;
477 static int yy_start_stack_depth = 0;
478 static int *yy_start_stack = 0;
479 #ifndef YY_NO_PUSH_STATE
480 static void yy_push_state YY_PROTO(( int new_state ));
481 #endif
482 #ifndef YY_NO_POP_STATE
483 static void yy_pop_state YY_PROTO(( void ));
484 #endif
485 #ifndef YY_NO_TOP_STATE
486 static int yy_top_state YY_PROTO(( void ));
487 #endif
488
489 #else
490 #define YY_NO_PUSH_STATE 1
491 #define YY_NO_POP_STATE 1
492 #define YY_NO_TOP_STATE 1
493 #endif
494
495 #ifdef YY_MALLOC_DECL
496 YY_MALLOC_DECL
497 #else
498 #if __STDC__
499 #ifndef __cplusplus
500 #include <stdlib.h>
501 #endif
502 #else
503 /* Just try to get by without declaring the routines.  This will fail
504  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
505  * or sizeof(void*) != sizeof(int).
506  */
507 #endif
508 #endif
509
510 /* Amount of stuff to slurp up with each read. */
511 #ifndef YY_READ_BUF_SIZE
512 #define YY_READ_BUF_SIZE 8192
513 #endif
514
515 /* Copy whatever the last rule matched to the standard output. */
516
517 #ifndef ECHO
518 /* This used to be an fputs(), but since the string might contain NUL's,
519  * we now use fwrite().
520  */
521 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
522 #endif
523
524 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
525  * is returned in "result".
526  */
527 #ifndef YY_INPUT
528 #define YY_INPUT(buf,result,max_size) \
529         if ( yy_current_buffer->yy_is_interactive ) \
530                 { \
531                 int c = '*', n; \
532                 for ( n = 0; n < max_size && \
533                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
534                         buf[n] = (char) c; \
535                 if ( c == '\n' ) \
536                         buf[n++] = (char) c; \
537                 if ( c == EOF && ferror( yyin ) ) \
538                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
539                 result = n; \
540                 } \
541         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
542                   && ferror( yyin ) ) \
543                 YY_FATAL_ERROR( "input in flex scanner failed" );
544 #endif
545
546 /* No semi-colon after return; correct usage is to write "yyterminate();" -
547  * we don't want an extra ';' after the "return" because that will cause
548  * some compilers to complain about unreachable statements.
549  */
550 #ifndef yyterminate
551 #define yyterminate() return YY_NULL
552 #endif
553
554 /* Number of entries by which start-condition stack grows. */
555 #ifndef YY_START_STACK_INCR
556 #define YY_START_STACK_INCR 25
557 #endif
558
559 /* Report a fatal error. */
560 #ifndef YY_FATAL_ERROR
561 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
562 #endif
563
564 /* Default declaration of generated scanner - a define so the user can
565  * easily add parameters.
566  */
567 #ifndef YY_DECL
568 #define YY_DECL int yylex YY_PROTO(( void ))
569 #endif
570
571 /* Code executed at the beginning of each rule, after yytext and yyleng
572  * have been set up.
573  */
574 #ifndef YY_USER_ACTION
575 #define YY_USER_ACTION
576 #endif
577
578 /* Code executed at the end of each rule. */
579 #ifndef YY_BREAK
580 #define YY_BREAK break;
581 #endif
582
583 #define YY_RULE_SETUP \
584         YY_USER_ACTION
585
586 YY_DECL
587         {
588         register yy_state_type yy_current_state;
589         register char *yy_cp, *yy_bp;
590         register int yy_act;
591
592 #line 13 "xl-sfspec.l"
593
594
595         if ( yy_init )
596                 {
597                 yy_init = 0;
598
599 #ifdef YY_USER_INIT
600                 YY_USER_INIT;
601 #endif
602
603                 if ( ! yy_start )
604                         yy_start = 1;   /* first start state */
605
606                 if ( ! yyin )
607                         yyin = stdin;
608
609                 if ( ! yyout )
610                         yyout = stdout;
611
612                 if ( ! yy_current_buffer )
613                         yy_current_buffer =
614                                 yy_create_buffer( yyin, YY_BUF_SIZE );
615
616                 yy_load_buffer_state();
617                 }
618
619         while ( 1 )             /* loops until end-of-file is reached */
620                 {
621                 yy_cp = yy_c_buf_p;
622
623                 /* Support of yytext. */
624                 *yy_cp = yy_hold_char;
625
626                 /* yy_bp points to the position in yy_ch_buf of the start of
627                  * the current run.
628                  */
629                 yy_bp = yy_cp;
630
631                 yy_current_state = yy_start;
632 yy_match:
633                 do
634                         {
635                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
636                         if ( yy_accept[yy_current_state] )
637                                 {
638                                 yy_last_accepting_state = yy_current_state;
639                                 yy_last_accepting_cpos = yy_cp;
640                                 }
641                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
642                                 {
643                                 yy_current_state = (int) yy_def[yy_current_state];
644                                 if ( yy_current_state >= 108 )
645                                         yy_c = yy_meta[(unsigned int) yy_c];
646                                 }
647                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
648                         ++yy_cp;
649                         }
650                 while ( yy_base[yy_current_state] != 159 );
651
652 yy_find_action:
653                 yy_act = yy_accept[yy_current_state];
654                 if ( yy_act == 0 )
655                         { /* have to back up */
656                         yy_cp = yy_last_accepting_cpos;
657                         yy_current_state = yy_last_accepting_state;
658                         yy_act = yy_accept[yy_current_state];
659                         }
660
661                 YY_DO_BEFORE_ACTION;
662
663
664 do_action:      /* This label is used only to access EOF actions. */
665
666
667                 switch ( yy_act )
668         { /* beginning of action switch */
669                         case 0: /* must back up */
670                         /* undo the effects of YY_DO_BEFORE_ACTION */
671                         *yy_cp = yy_hold_char;
672                         yy_cp = yy_last_accepting_cpos;
673                         yy_current_state = yy_last_accepting_state;
674                         goto yy_find_action;
675
676 case 1:
677 YY_RULE_SETUP
678 #line 14 "xl-sfspec.l"
679 { CheckReturns(yytext);fprintf(yyout,"CreateChare("); }
680         YY_BREAK
681 case 2:
682 YY_RULE_SETUP
683 #line 15 "xl-sfspec.l"
684 { CheckReturns(yytext);fprintf(yyout,"CreateBoc("); }
685         YY_BREAK
686 case 3:
687 YY_RULE_SETUP
688 #line 16 "xl-sfspec.l"
689 { CheckReturns(yytext);fprintf(yyout,"MyBocNum("); }
690         YY_BREAK
691 case 4:
692 YY_RULE_SETUP
693 #line 17 "xl-sfspec.l"
694 { CheckReturns(yytext);fprintf(yyout,"MyBranchID("); }
695         YY_BREAK
696 case 5:
697 YY_RULE_SETUP
698 #line 18 "xl-sfspec.l"
699 { CheckReturns(yytext);fprintf(yyout,"SendMsgBranch("); }
700         YY_BREAK
701 case 6:
702 YY_RULE_SETUP
703 #line 19 "xl-sfspec.l"
704 { CheckReturns(yytext);fprintf(yyout,"ImmSendMsgBranch("); }
705         YY_BREAK
706 case 7:
707 YY_RULE_SETUP
708 #line 20 "xl-sfspec.l"
709 { CheckReturns(yytext);fprintf(yyout,"BroadcastMsgBranch("); }
710         YY_BREAK
711 case 8:
712 YY_RULE_SETUP
713 #line 21 "xl-sfspec.l"
714 { currentline=GetLine(yytext);fprintf(yyout,"%s",yytext); }
715         YY_BREAK
716 case 9:
717 YY_RULE_SETUP
718 #line 22 "xl-sfspec.l"
719 { currentline = GetLine(yytext);
720                            output_proper_line(yytext);}
721         YY_BREAK
722 case 10:
723 YY_RULE_SETUP
724 #line 24 "xl-sfspec.l"
725 { CountReturns(yytext); fprintf(yyout,"%s",yytext); }
726         YY_BREAK
727 case 11:
728 YY_RULE_SETUP
729 #line 25 "xl-sfspec.l"
730 ECHO;
731         YY_BREAK
732 case YY_STATE_EOF(INITIAL):
733         yyterminate();
734
735         case YY_END_OF_BUFFER:
736                 {
737                 /* Amount of text matched not including the EOB char. */
738                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
739
740                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
741                 *yy_cp = yy_hold_char;
742                 YY_RESTORE_YY_MORE_OFFSET
743
744                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
745                         {
746                         /* We're scanning a new file or input source.  It's
747                          * possible that this happened because the user
748                          * just pointed yyin at a new source and called
749                          * yylex().  If so, then we have to assure
750                          * consistency between yy_current_buffer and our
751                          * globals.  Here is the right place to do so, because
752                          * this is the first action (other than possibly a
753                          * back-up) that will match for the new input source.
754                          */
755                         yy_n_chars = yy_current_buffer->yy_n_chars;
756                         yy_current_buffer->yy_input_file = yyin;
757                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
758                         }
759
760                 /* Note that here we test for yy_c_buf_p "<=" to the position
761                  * of the first EOB in the buffer, since yy_c_buf_p will
762                  * already have been incremented past the NUL character
763                  * (since all states make transitions on EOB to the
764                  * end-of-buffer state).  Contrast this with the test
765                  * in input().
766                  */
767                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
768                         { /* This was really a NUL. */
769                         yy_state_type yy_next_state;
770
771                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
772
773                         yy_current_state = yy_get_previous_state();
774
775                         /* Okay, we're now positioned to make the NUL
776                          * transition.  We couldn't have
777                          * yy_get_previous_state() go ahead and do it
778                          * for us because it doesn't know how to deal
779                          * with the possibility of jamming (and we don't
780                          * want to build jamming into it because then it
781                          * will run more slowly).
782                          */
783
784                         yy_next_state = yy_try_NUL_trans( yy_current_state );
785
786                         yy_bp = yytext_ptr + YY_MORE_ADJ;
787
788                         if ( yy_next_state )
789                                 {
790                                 /* Consume the NUL. */
791                                 yy_cp = ++yy_c_buf_p;
792                                 yy_current_state = yy_next_state;
793                                 goto yy_match;
794                                 }
795
796                         else
797                                 {
798                                 yy_cp = yy_c_buf_p;
799                                 goto yy_find_action;
800                                 }
801                         }
802
803                 else switch ( yy_get_next_buffer() )
804                         {
805                         case EOB_ACT_END_OF_FILE:
806                                 {
807                                 yy_did_buffer_switch_on_eof = 0;
808
809                                 if ( yywrap() )
810                                         {
811                                         /* Note: because we've taken care in
812                                          * yy_get_next_buffer() to have set up
813                                          * yytext, we can now set up
814                                          * yy_c_buf_p so that if some total
815                                          * hoser (like flex itself) wants to
816                                          * call the scanner after we return the
817                                          * YY_NULL, it'll still work - another
818                                          * YY_NULL will get returned.
819                                          */
820                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
821
822                                         yy_act = YY_STATE_EOF(YY_START);
823                                         goto do_action;
824                                         }
825
826                                 else
827                                         {
828                                         if ( ! yy_did_buffer_switch_on_eof )
829                                                 YY_NEW_FILE;
830                                         }
831                                 break;
832                                 }
833
834                         case EOB_ACT_CONTINUE_SCAN:
835                                 yy_c_buf_p =
836                                         yytext_ptr + yy_amount_of_matched_text;
837
838                                 yy_current_state = yy_get_previous_state();
839
840                                 yy_cp = yy_c_buf_p;
841                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
842                                 goto yy_match;
843
844                         case EOB_ACT_LAST_MATCH:
845                                 yy_c_buf_p =
846                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
847
848                                 yy_current_state = yy_get_previous_state();
849
850                                 yy_cp = yy_c_buf_p;
851                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
852                                 goto yy_find_action;
853                         }
854                 break;
855                 }
856
857         default:
858                 YY_FATAL_ERROR(
859                         "fatal flex scanner internal error--no action found" );
860         } /* end of action switch */
861                 } /* end of scanning one token */
862         } /* end of yylex */
863
864
865 /* yy_get_next_buffer - try to read in a new buffer
866  *
867  * Returns a code representing an action:
868  *      EOB_ACT_LAST_MATCH -
869  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
870  *      EOB_ACT_END_OF_FILE - end of file
871  */
872
873 static int yy_get_next_buffer()
874         {
875         register char *dest = yy_current_buffer->yy_ch_buf;
876         register char *source = yytext_ptr;
877         register int number_to_move, i;
878         int ret_val;
879
880         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
881                 YY_FATAL_ERROR(
882                 "fatal flex scanner internal error--end of buffer missed" );
883
884         if ( yy_current_buffer->yy_fill_buffer == 0 )
885                 { /* Don't try to fill the buffer, so this is an EOF. */
886                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
887                         {
888                         /* We matched a single character, the EOB, so
889                          * treat this as a final EOF.
890                          */
891                         return EOB_ACT_END_OF_FILE;
892                         }
893
894                 else
895                         {
896                         /* We matched some text prior to the EOB, first
897                          * process it.
898                          */
899                         return EOB_ACT_LAST_MATCH;
900                         }
901                 }
902
903         /* Try to read more data. */
904
905         /* First move last chars to start of buffer. */
906         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
907
908         for ( i = 0; i < number_to_move; ++i )
909                 *(dest++) = *(source++);
910
911         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
912                 /* don't do the read, it's not guaranteed to return an EOF,
913                  * just force an EOF
914                  */
915                 yy_n_chars = 0;
916
917         else
918                 {
919                 int num_to_read =
920                         yy_current_buffer->yy_buf_size - number_to_move - 1;
921
922                 while ( num_to_read <= 0 )
923                         { /* Not enough room in the buffer - grow it. */
924 #ifdef YY_USES_REJECT
925                         YY_FATAL_ERROR(
926 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
927 #else
928
929                         /* just a shorter name for the current buffer */
930                         YY_BUFFER_STATE b = yy_current_buffer;
931
932                         int yy_c_buf_p_offset =
933                                 (int) (yy_c_buf_p - b->yy_ch_buf);
934
935                         if ( b->yy_is_our_buffer )
936                                 {
937                                 int new_size = b->yy_buf_size * 2;
938
939                                 if ( new_size <= 0 )
940                                         b->yy_buf_size += b->yy_buf_size / 8;
941                                 else
942                                         b->yy_buf_size *= 2;
943
944                                 b->yy_ch_buf = (char *)
945                                         /* Include room in for 2 EOB chars. */
946                                         yy_flex_realloc( (void *) b->yy_ch_buf,
947                                                          b->yy_buf_size + 2 );
948                                 }
949                         else
950                                 /* Can't grow it, we don't own it. */
951                                 b->yy_ch_buf = 0;
952
953                         if ( ! b->yy_ch_buf )
954                                 YY_FATAL_ERROR(
955                                 "fatal error - scanner input buffer overflow" );
956
957                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
958
959                         num_to_read = yy_current_buffer->yy_buf_size -
960                                                 number_to_move - 1;
961 #endif
962                         }
963
964                 if ( num_to_read > YY_READ_BUF_SIZE )
965                         num_to_read = YY_READ_BUF_SIZE;
966
967                 /* Read in more data. */
968                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
969                         yy_n_chars, num_to_read );
970                 }
971
972         if ( yy_n_chars == 0 )
973                 {
974                 if ( number_to_move == YY_MORE_ADJ )
975                         {
976                         ret_val = EOB_ACT_END_OF_FILE;
977                         yyrestart( yyin );
978                         }
979
980                 else
981                         {
982                         ret_val = EOB_ACT_LAST_MATCH;
983                         yy_current_buffer->yy_buffer_status =
984                                 YY_BUFFER_EOF_PENDING;
985                         }
986                 }
987
988         else
989                 ret_val = EOB_ACT_CONTINUE_SCAN;
990
991         yy_n_chars += number_to_move;
992         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
993         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
994
995         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
996
997         return ret_val;
998         }
999
1000
1001 /* yy_get_previous_state - get the state just before the EOB char was reached */
1002
1003 static yy_state_type yy_get_previous_state()
1004         {
1005         register yy_state_type yy_current_state;
1006         register char *yy_cp;
1007
1008         yy_current_state = yy_start;
1009
1010         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1011                 {
1012                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1013                 if ( yy_accept[yy_current_state] )
1014                         {
1015                         yy_last_accepting_state = yy_current_state;
1016                         yy_last_accepting_cpos = yy_cp;
1017                         }
1018                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1019                         {
1020                         yy_current_state = (int) yy_def[yy_current_state];
1021                         if ( yy_current_state >= 108 )
1022                                 yy_c = yy_meta[(unsigned int) yy_c];
1023                         }
1024                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1025                 }
1026
1027         return yy_current_state;
1028         }
1029
1030
1031 /* yy_try_NUL_trans - try to make a transition on the NUL character
1032  *
1033  * synopsis
1034  *      next_state = yy_try_NUL_trans( current_state );
1035  */
1036
1037 #ifdef YY_USE_PROTOS
1038 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1039 #else
1040 static yy_state_type yy_try_NUL_trans( yy_current_state )
1041 yy_state_type yy_current_state;
1042 #endif
1043         {
1044         register int yy_is_jam;
1045         register char *yy_cp = yy_c_buf_p;
1046
1047         register YY_CHAR yy_c = 1;
1048         if ( yy_accept[yy_current_state] )
1049                 {
1050                 yy_last_accepting_state = yy_current_state;
1051                 yy_last_accepting_cpos = yy_cp;
1052                 }
1053         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1054                 {
1055                 yy_current_state = (int) yy_def[yy_current_state];
1056                 if ( yy_current_state >= 108 )
1057                         yy_c = yy_meta[(unsigned int) yy_c];
1058                 }
1059         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1060         yy_is_jam = (yy_current_state == 107);
1061
1062         return yy_is_jam ? 0 : yy_current_state;
1063         }
1064
1065
1066 #ifndef YY_NO_UNPUT
1067 #ifdef YY_USE_PROTOS
1068 static void yyunput( int c, register char *yy_bp )
1069 #else
1070 static void yyunput( c, yy_bp )
1071 int c;
1072 register char *yy_bp;
1073 #endif
1074         {
1075         register char *yy_cp = yy_c_buf_p;
1076
1077         /* undo effects of setting up yytext */
1078         *yy_cp = yy_hold_char;
1079
1080         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1081                 { /* need to shift things up to make room */
1082                 /* +2 for EOB chars. */
1083                 register int number_to_move = yy_n_chars + 2;
1084                 register char *dest = &yy_current_buffer->yy_ch_buf[
1085                                         yy_current_buffer->yy_buf_size + 2];
1086                 register char *source =
1087                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1088
1089                 while ( source > yy_current_buffer->yy_ch_buf )
1090                         *--dest = *--source;
1091
1092                 yy_cp += (int) (dest - source);
1093                 yy_bp += (int) (dest - source);
1094                 yy_n_chars = yy_current_buffer->yy_buf_size;
1095
1096                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1097                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1098                 }
1099
1100         *--yy_cp = (char) c;
1101
1102
1103         yytext_ptr = yy_bp;
1104         yy_hold_char = *yy_cp;
1105         yy_c_buf_p = yy_cp;
1106         }
1107 #endif  /* ifndef YY_NO_UNPUT */
1108
1109
1110 #ifdef __cplusplus
1111 static int yyinput()
1112 #else
1113 static int input()
1114 #endif
1115         {
1116         int c;
1117
1118         *yy_c_buf_p = yy_hold_char;
1119
1120         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1121                 {
1122                 /* yy_c_buf_p now points to the character we want to return.
1123                  * If this occurs *before* the EOB characters, then it's a
1124                  * valid NUL; if not, then we've hit the end of the buffer.
1125                  */
1126                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1127                         /* This was really a NUL. */
1128                         *yy_c_buf_p = '\0';
1129
1130                 else
1131                         { /* need more input */
1132                         int offset = yy_c_buf_p - yytext_ptr;
1133                         ++yy_c_buf_p;
1134
1135                         switch ( yy_get_next_buffer() )
1136                                 {
1137                                 case EOB_ACT_END_OF_FILE:
1138                                         {
1139                                         if ( yywrap() )
1140                                                 {
1141                                                 yy_c_buf_p = yytext_ptr + offset;
1142                                                 return EOF;
1143                                                 }
1144
1145                                         if ( ! yy_did_buffer_switch_on_eof )
1146                                                 YY_NEW_FILE;
1147 #ifdef __cplusplus
1148                                         return yyinput();
1149 #else
1150                                         return input();
1151 #endif
1152                                         }
1153
1154                                 case EOB_ACT_CONTINUE_SCAN:
1155                                         yy_c_buf_p = yytext_ptr + offset;
1156                                         break;
1157
1158                                 case EOB_ACT_LAST_MATCH:
1159 #ifdef __cplusplus
1160                                         YY_FATAL_ERROR(
1161                                         "unexpected last match in yyinput()" );
1162 #else
1163                                         YY_FATAL_ERROR(
1164                                         "unexpected last match in input()" );
1165 #endif
1166                                 }
1167                         }
1168                 }
1169
1170         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1171         *yy_c_buf_p = '\0';     /* preserve yytext */
1172         yy_hold_char = *++yy_c_buf_p;
1173
1174
1175         return c;
1176         }
1177
1178
1179 #ifdef YY_USE_PROTOS
1180 void yyrestart( FILE *input_file )
1181 #else
1182 void yyrestart( input_file )
1183 FILE *input_file;
1184 #endif
1185         {
1186         if ( ! yy_current_buffer )
1187                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1188
1189         yy_init_buffer( yy_current_buffer, input_file );
1190         yy_load_buffer_state();
1191         }
1192
1193
1194 #ifdef YY_USE_PROTOS
1195 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1196 #else
1197 void yy_switch_to_buffer( new_buffer )
1198 YY_BUFFER_STATE new_buffer;
1199 #endif
1200         {
1201         if ( yy_current_buffer == new_buffer )
1202                 return;
1203
1204         if ( yy_current_buffer )
1205                 {
1206                 /* Flush out information for old buffer. */
1207                 *yy_c_buf_p = yy_hold_char;
1208                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1209                 yy_current_buffer->yy_n_chars = yy_n_chars;
1210                 }
1211
1212         yy_current_buffer = new_buffer;
1213         yy_load_buffer_state();
1214
1215         /* We don't actually know whether we did this switch during
1216          * EOF (yywrap()) processing, but the only time this flag
1217          * is looked at is after yywrap() is called, so it's safe
1218          * to go ahead and always set it.
1219          */
1220         yy_did_buffer_switch_on_eof = 1;
1221         }
1222
1223
1224 #ifdef YY_USE_PROTOS
1225 void yy_load_buffer_state( void )
1226 #else
1227 void yy_load_buffer_state()
1228 #endif
1229         {
1230         yy_n_chars = yy_current_buffer->yy_n_chars;
1231         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1232         yyin = yy_current_buffer->yy_input_file;
1233         yy_hold_char = *yy_c_buf_p;
1234         }
1235
1236
1237 #ifdef YY_USE_PROTOS
1238 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1239 #else
1240 YY_BUFFER_STATE yy_create_buffer( file, size )
1241 FILE *file;
1242 int size;
1243 #endif
1244         {
1245         YY_BUFFER_STATE b;
1246
1247         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1248         if ( ! b )
1249                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1250
1251         b->yy_buf_size = size;
1252
1253         /* yy_ch_buf has to be 2 characters longer than the size given because
1254          * we need to put in 2 end-of-buffer characters.
1255          */
1256         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1257         if ( ! b->yy_ch_buf )
1258                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1259
1260         b->yy_is_our_buffer = 1;
1261
1262         yy_init_buffer( b, file );
1263
1264         return b;
1265         }
1266
1267
1268 #ifdef YY_USE_PROTOS
1269 void yy_delete_buffer( YY_BUFFER_STATE b )
1270 #else
1271 void yy_delete_buffer( b )
1272 YY_BUFFER_STATE b;
1273 #endif
1274         {
1275         if ( ! b )
1276                 return;
1277
1278         if ( b == yy_current_buffer )
1279                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1280
1281         if ( b->yy_is_our_buffer )
1282                 yy_flex_free( (void *) b->yy_ch_buf );
1283
1284         yy_flex_free( (void *) b );
1285         }
1286
1287
1288 #ifndef YY_ALWAYS_INTERACTIVE
1289 #ifndef YY_NEVER_INTERACTIVE
1290 extern int isatty YY_PROTO(( int ));
1291 #endif
1292 #endif
1293
1294 #ifdef YY_USE_PROTOS
1295 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1296 #else
1297 void yy_init_buffer( b, file )
1298 YY_BUFFER_STATE b;
1299 FILE *file;
1300 #endif
1301
1302
1303         {
1304         yy_flush_buffer( b );
1305
1306         b->yy_input_file = file;
1307         b->yy_fill_buffer = 1;
1308
1309 #if YY_ALWAYS_INTERACTIVE
1310         b->yy_is_interactive = 1;
1311 #else
1312 #if YY_NEVER_INTERACTIVE
1313         b->yy_is_interactive = 0;
1314 #else
1315         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1316 #endif
1317 #endif
1318         }
1319
1320
1321 #ifdef YY_USE_PROTOS
1322 void yy_flush_buffer( YY_BUFFER_STATE b )
1323 #else
1324 void yy_flush_buffer( b )
1325 YY_BUFFER_STATE b;
1326 #endif
1327
1328         {
1329         b->yy_n_chars = 0;
1330
1331         /* We always need two end-of-buffer characters.  The first causes
1332          * a transition to the end-of-buffer state.  The second causes
1333          * a jam in that state.
1334          */
1335         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1336         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1337
1338         b->yy_buf_pos = &b->yy_ch_buf[0];
1339
1340         b->yy_at_bol = 1;
1341         b->yy_buffer_status = YY_BUFFER_NEW;
1342
1343         if ( b == yy_current_buffer )
1344                 yy_load_buffer_state();
1345         }
1346
1347
1348 #ifndef YY_NO_SCAN_BUFFER
1349 #ifdef YY_USE_PROTOS
1350 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1351 #else
1352 YY_BUFFER_STATE yy_scan_buffer( base, size )
1353 char *base;
1354 yy_size_t size;
1355 #endif
1356         {
1357         YY_BUFFER_STATE b;
1358
1359         if ( size < 2 ||
1360              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1361              base[size-1] != YY_END_OF_BUFFER_CHAR )
1362                 /* They forgot to leave room for the EOB's. */
1363                 return 0;
1364
1365         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1366         if ( ! b )
1367                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1368
1369         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1370         b->yy_buf_pos = b->yy_ch_buf = base;
1371         b->yy_is_our_buffer = 0;
1372         b->yy_input_file = 0;
1373         b->yy_n_chars = b->yy_buf_size;
1374         b->yy_is_interactive = 0;
1375         b->yy_at_bol = 1;
1376         b->yy_fill_buffer = 0;
1377         b->yy_buffer_status = YY_BUFFER_NEW;
1378
1379         yy_switch_to_buffer( b );
1380
1381         return b;
1382         }
1383 #endif
1384
1385
1386 #ifndef YY_NO_SCAN_STRING
1387 #ifdef YY_USE_PROTOS
1388 YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1389 #else
1390 YY_BUFFER_STATE yy_scan_string( str )
1391 yyconst char *str;
1392 #endif
1393         {
1394         int len;
1395         for ( len = 0; str[len]; ++len )
1396                 ;
1397
1398         return yy_scan_bytes( str, len );
1399         }
1400 #endif
1401
1402
1403 #ifndef YY_NO_SCAN_BYTES
1404 #ifdef YY_USE_PROTOS
1405 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1406 #else
1407 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1408 yyconst char *bytes;
1409 int len;
1410 #endif
1411         {
1412         YY_BUFFER_STATE b;
1413         char *buf;
1414         yy_size_t n;
1415         int i;
1416
1417         /* Get memory for full buffer, including space for trailing EOB's. */
1418         n = len + 2;
1419         buf = (char *) yy_flex_alloc( n );
1420         if ( ! buf )
1421                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1422
1423         for ( i = 0; i < len; ++i )
1424                 buf[i] = bytes[i];
1425
1426         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1427
1428         b = yy_scan_buffer( buf, n );
1429         if ( ! b )
1430                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1431
1432         /* It's okay to grow etc. this buffer, and we should throw it
1433          * away when we're done.
1434          */
1435         b->yy_is_our_buffer = 1;
1436
1437         return b;
1438         }
1439 #endif
1440
1441
1442 #ifndef YY_NO_PUSH_STATE
1443 #ifdef YY_USE_PROTOS
1444 static void yy_push_state( int new_state )
1445 #else
1446 static void yy_push_state( new_state )
1447 int new_state;
1448 #endif
1449         {
1450         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1451                 {
1452                 yy_size_t new_size;
1453
1454                 yy_start_stack_depth += YY_START_STACK_INCR;
1455                 new_size = yy_start_stack_depth * sizeof( int );
1456
1457                 if ( ! yy_start_stack )
1458                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1459
1460                 else
1461                         yy_start_stack = (int *) yy_flex_realloc(
1462                                         (void *) yy_start_stack, new_size );
1463
1464                 if ( ! yy_start_stack )
1465                         YY_FATAL_ERROR(
1466                         "out of memory expanding start-condition stack" );
1467                 }
1468
1469         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1470
1471         BEGIN(new_state);
1472         }
1473 #endif
1474
1475
1476 #ifndef YY_NO_POP_STATE
1477 static void yy_pop_state()
1478         {
1479         if ( --yy_start_stack_ptr < 0 )
1480                 YY_FATAL_ERROR( "start-condition stack underflow" );
1481
1482         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1483         }
1484 #endif
1485
1486
1487 #ifndef YY_NO_TOP_STATE
1488 static int yy_top_state()
1489         {
1490         return yy_start_stack[yy_start_stack_ptr - 1];
1491         }
1492 #endif
1493
1494 #ifndef YY_EXIT_FAILURE
1495 #define YY_EXIT_FAILURE 2
1496 #endif
1497
1498 #ifdef YY_USE_PROTOS
1499 static void yy_fatal_error( yyconst char msg[] )
1500 #else
1501 static void yy_fatal_error( msg )
1502 char msg[];
1503 #endif
1504         {
1505         (void) fprintf( stderr, "%s\n", msg );
1506         exit( YY_EXIT_FAILURE );
1507         }
1508
1509
1510
1511 /* Redefine yyless() so it works in section 3 code. */
1512
1513 #undef yyless
1514 #define yyless(n) \
1515         do \
1516                 { \
1517                 /* Undo effects of setting up yytext. */ \
1518                 yytext[yyleng] = yy_hold_char; \
1519                 yy_c_buf_p = yytext + n; \
1520                 yy_hold_char = *yy_c_buf_p; \
1521                 *yy_c_buf_p = '\0'; \
1522                 yyleng = n; \
1523                 } \
1524         while ( 0 )
1525
1526
1527 /* Internal utility routines. */
1528
1529 #ifndef yytext_ptr
1530 #ifdef YY_USE_PROTOS
1531 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1532 #else
1533 static void yy_flex_strncpy( s1, s2, n )
1534 char *s1;
1535 yyconst char *s2;
1536 int n;
1537 #endif
1538         {
1539         register int i;
1540         for ( i = 0; i < n; ++i )
1541                 s1[i] = s2[i];
1542         }
1543 #endif
1544
1545 #ifdef YY_NEED_STRLEN
1546 #ifdef YY_USE_PROTOS
1547 static int yy_flex_strlen( yyconst char *s )
1548 #else
1549 static int yy_flex_strlen( s )
1550 yyconst char *s;
1551 #endif
1552         {
1553         register int n;
1554         for ( n = 0; s[n]; ++n )
1555                 ;
1556
1557         return n;
1558         }
1559 #endif
1560
1561
1562 #ifdef YY_USE_PROTOS
1563 static void *yy_flex_alloc( yy_size_t size )
1564 #else
1565 static void *yy_flex_alloc( size )
1566 yy_size_t size;
1567 #endif
1568         {
1569         return (void *) malloc( size );
1570         }
1571
1572 #ifdef YY_USE_PROTOS
1573 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1574 #else
1575 static void *yy_flex_realloc( ptr, size )
1576 void *ptr;
1577 yy_size_t size;
1578 #endif
1579         {
1580         /* The cast to (char *) in the following accommodates both
1581          * implementations that use char* generic pointers, and those
1582          * that use void* generic pointers.  It works with the latter
1583          * because both ANSI C and C++ allow castless assignment from
1584          * any pointer type to void*, and deal with argument conversions
1585          * as though doing an assignment.
1586          */
1587         return (void *) realloc( (char *) ptr, size );
1588         }
1589
1590 #ifdef YY_USE_PROTOS
1591 static void yy_flex_free( void *ptr )
1592 #else
1593 static void yy_flex_free( ptr )
1594 void *ptr;
1595 #endif
1596         {
1597         free( ptr );
1598         }
1599
1600 #if YY_MAIN
1601 int main()
1602         {
1603         yylex();
1604         return 0;
1605         }
1606 #endif
1607 #line 25 "xl-sfspec.l"
1608
1609
1610 yywrap(){ return(1); }
1611
1612 main() { writem4(); writeundef(); yylex(); }
1613
1614 GetLine(string)
1615 char string[];
1616 { int i=0,j;
1617   char dummy[10];
1618
1619   while ((string[i]<'0')||(string[i]>'9')) i++;
1620   j=0;
1621   while ((string[i]>='0')&&(string[i]<='9')) dummy[j++] = string[i++];
1622   dummy[j]='\0';
1623   return(atoi(dummy));
1624 }
1625
1626 output_proper_line(string)
1627 char string[];
1628 {
1629    int length;
1630
1631    length=strlen(string)-1;
1632    while (string[length-1]!='"') length--;
1633    string[length]='\0';
1634    fprintf(yyout,"%s",string);
1635 }
1636
1637 CountReturns(string)
1638 char *string;
1639 {
1640   while (*string) {
1641     if (*string=='\n') currentline++;
1642     string++;
1643   }
1644 }
1645
1646 CheckReturns(string)
1647 char *string;
1648 {
1649   int anyret=0;
1650   while (*string) {
1651     if (*string=='\n') { currentline++; anyret=1; }
1652     string++;
1653   }
1654   if (anyret)
1655     fprintf(yyout,"# line %d\n",currentline);
1656 }
1657
1658
1659 char *createchare="define(CreateChare,`_CK_CreateChare($1,$2,$3,ifelse($4,,NULL_VID,$4),ifelse($5,,NULL_PE,$5))')";
1660
1661 char *createboc="define(CreateBoc,`_CK_CreateBoc($1,$2,$3,ifelse($4,,-1`,'NULL,$4`,'$5))')";
1662
1663 char *mybocnum="define(MyBocNum,`_CK_MyBocNum(_CK_4mydata)')";
1664 char *mybranchid="define(MyBranchID,`_CK_MyBranchID($1,_CK_4mydata)')";
1665 char *sendmsgbranch="define(SendMsgBranch,`_CK_SendMsgBranch($1,$2,ifelse($4,,_CK_MyBocNum(_CK_4mydata),$4),$3)')";
1666 char *immsendmsgbranch="define(ImmSendMsgBranch,`_CK_ImmSendMsgBranch($1,$2,ifelse($4,,_CK_MyBocNum(_CK_4mydata),$4),$3)')";
1667 char *broadcastmsgbranch="define(BroadcastMsgBranch,`_CK_BroadcastMsgBranch($1,$2,ifelse($3,,_CK_MyBocNum(_CK_4mydata),$3))')";
1668 char *createacc="define(CreateAcc,`_CK_CreateAcc($1,$2,ifelse($3,,-1`,'NULL,$3`,'$4))')";
1669 char *createmono="define(CreateMono,`_CK_CreateMono($1,$2,ifelse($3,,-1`,'NULL,$3`,'$4))')";
1670
1671 writem4()
1672 { printf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",createchare,createboc,mybocnum,mybranchid,
1673                 sendmsgbranch,immsendmsgbranch,broadcastmsgbranch,createacc,createmono);
1674 }
1675
1676 writeundef()
1677 { printf("undefine(`changequote')\n");
1678   printf("undefine(`divert')\n");
1679   printf("undefine(`divnum')\n");
1680   printf("undefine(`dnl')\n");
1681   printf("undefine(`dumpdef')\n");
1682   printf("undefine(`errprint')\n");
1683   printf("undefine(`eval')\n");
1684   printf("undefine(`ifdef')\n");
1685   printf("undefine(`include')\n");
1686   printf("undefine(`incr')\n");
1687   printf("undefine(`index')\n");
1688   printf("undefine(`len')\n");
1689   printf("undefine(`maketemp')\n");
1690   printf("undefine(`sinclude')\n");
1691   printf("undefine(`substr')\n");
1692   printf("undefine(`syscmd')\n");
1693   printf("undefine(`translit')\n");
1694   printf("undefine(`undivert')\n");
1695   printf("undefine(`define')\n");
1696   printf("undefine(`undefine')\n");
1697 }