88f946e0bf247b4957f27de3303005207e047602
[occt.git] / src / StepFile / lex.step.c
1 #define yy_create_buffer step_create_buffer
2 #define yy_delete_buffer step_delete_buffer
3 #define yy_scan_buffer step_scan_buffer
4 #define yy_scan_string step_scan_string
5 #define yy_scan_bytes step_scan_bytes
6 #define yy_flex_debug step_flex_debug
7 #define yy_init_buffer step_init_buffer
8 #define yy_flush_buffer step_flush_buffer
9 #define yy_load_buffer_state step_load_buffer_state
10 #define yy_switch_to_buffer step_switch_to_buffer
11 #define yyin stepin
12 #define yyleng stepleng
13 #define yylex steplex
14 #define yyout stepout
15 #define yyrestart steprestart
16 #define yytext steptext
17 #define yywrap stepwrap
18
19 /* A lexical scanner generated by flex */
20
21 /* Scanner skeleton version:
22  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.89 96/05/25 21:02:21 vern Exp $
23  */
24
25 #define FLEX_SCANNER
26 #define YY_FLEX_MAJOR_VERSION 2
27 #define YY_FLEX_MINOR_VERSION 5
28
29 #include <stdio.h>
30
31 #ifdef _MSC_VER
32 # include <stdlib.h>
33 # include <io.h>
34 #endif  /* _MSC_VER */
35
36
37
38 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
39 #ifdef c_plusplus
40 #ifndef __cplusplus
41 #define __cplusplus
42 #endif
43 #endif
44
45
46 #ifdef __cplusplus
47
48 #include <stdlib.h>
49 #include <unistd.h>
50
51 /* Use prototypes in function declarations. */
52 #define YY_USE_PROTOS
53
54 /* The "const" storage-class-modifier is valid. */
55 #define YY_USE_CONST
56
57 #else   /* ! __cplusplus */
58
59 #if __STDC__
60
61 #define YY_USE_PROTOS
62 #define YY_USE_CONST
63
64 #endif  /* __STDC__ */
65 #endif  /* ! __cplusplus */
66
67 #ifdef __TURBOC__
68  #pragma warn -rch
69  #pragma warn -use
70 #include <io.h>
71 #include <stdlib.h>
72 #define YY_USE_CONST
73 #define YY_USE_PROTOS
74 #endif
75
76 #ifdef YY_USE_CONST
77 #define yyconst const
78 #else
79 #define yyconst
80 #endif
81
82
83 #ifdef YY_USE_PROTOS
84 #define YY_PROTO(proto) proto
85 #else
86 #define YY_PROTO(proto) ()
87 #endif
88
89 /* Returned upon end-of-file. */
90 #define YY_NULL 0
91
92 /* Promotes a possibly negative, possibly signed char to an unsigned
93  * integer for use as an array index.  If the signed char is negative,
94  * we want to instead treat it as an 8-bit unsigned char, hence the
95  * double cast.
96  */
97 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
98
99 /* Enter a start condition.  This macro really ought to take a parameter,
100  * but we do it the disgusting crufty way forced on us by the ()-less
101  * definition of BEGIN.
102  */
103 #define BEGIN yy_start = 1 + 2 *
104
105 /* Translate the current start state into a value that can be later handed
106  * to BEGIN to return to the state.  The YYSTATE alias is for lex
107  * compatibility.
108  */
109 #define YY_START ((yy_start - 1) / 2)
110 #define YYSTATE YY_START
111
112 /* Action number for EOF rule of a given start state. */
113 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
114
115 /* Special action meaning "start processing a new file". */
116 #define YY_NEW_FILE yyrestart( yyin )
117
118 #define YY_END_OF_BUFFER_CHAR 0
119
120 /* Size of default input buffer. */
121 #define YY_BUF_SIZE 16384
122
123 typedef struct yy_buffer_state *YY_BUFFER_STATE;
124
125 extern int yyleng;
126 extern FILE *yyin, *yyout;
127
128 #define EOB_ACT_CONTINUE_SCAN 0
129 #define EOB_ACT_END_OF_FILE 1
130 #define EOB_ACT_LAST_MATCH 2
131
132 /* The funky do-while in the following #define is used to turn the definition
133  * int a single C statement (which needs a semi-colon terminator).  This
134  * avoids problems with code like:
135  *
136  *      if ( condition_holds )
137  *              yyless( 5 );
138  *      else
139  *              do_something_else();
140  *
141  * Prior to using the do-while the compiler would get upset at the
142  * "else" because it interpreted the "if" statement as being all
143  * done when it reached the ';' after the yyless() call.
144  */
145
146 /* Return all but the first 'n' matched characters back to the input stream. */
147
148 #define yyless(n) \
149         do \
150                 { \
151                 /* Undo effects of setting up yytext. */ \
152                 *yy_cp = yy_hold_char; \
153                 YY_RESTORE_YY_MORE_OFFSET \
154                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
155                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
156                 } \
157         while ( 0 )
158
159 #define unput(c) yyunput( c, yytext_ptr )
160
161 /* The following is because we cannot portably get our hands on size_t
162  * (without autoconf's help, which isn't available because we want
163  * flex-generated scanners to compile on their own).
164  */
165 typedef unsigned int yy_size_t;
166
167
168 struct yy_buffer_state
169         {
170         FILE *yy_input_file;
171
172         char *yy_ch_buf;                /* input buffer */
173         char *yy_buf_pos;               /* current position in input buffer */
174
175         /* Size of input buffer in bytes, not including room for EOB
176          * characters.
177          */
178         yy_size_t yy_buf_size;
179
180         /* Number of characters read into yy_ch_buf, not including EOB
181          * characters.
182          */
183         int yy_n_chars;
184
185         /* Whether we "own" the buffer - i.e., we know we created it,
186          * and can realloc() it to grow it, and should free() it to
187          * delete it.
188          */
189         int yy_is_our_buffer;
190
191         /* Whether this is an "interactive" input source; if so, and
192          * if we're using stdio for input, then we want to use getc()
193          * instead of fread(), to make sure we stop fetching input after
194          * each newline.
195          */
196         int yy_is_interactive;
197
198         /* Whether we're considered to be at the beginning of a line.
199          * If so, '^' rules will be active on the next match, otherwise
200          * not.
201          */
202         int yy_at_bol;
203
204         /* Whether to try to fill the input buffer when we reach the
205          * end of it.
206          */
207         int yy_fill_buffer;
208
209         int yy_buffer_status;
210 #define YY_BUFFER_NEW 0
211 #define YY_BUFFER_NORMAL 1
212         /* When an EOF's been seen but there's still some text to process
213          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
214          * shouldn't try reading from the input source any more.  We might
215          * still have a bunch of tokens to match, though, because of
216          * possible backing-up.
217          *
218          * When we actually see the EOF, we change the status to "new"
219          * (via yyrestart()), so that the user can continue scanning by
220          * just pointing yyin at a new input file.
221          */
222 #define YY_BUFFER_EOF_PENDING 2
223         };
224
225 static YY_BUFFER_STATE yy_current_buffer = 0;
226
227 /* We provide macros for accessing buffer states in case in the
228  * future we want to put the buffer states in a more general
229  * "scanner state".
230  */
231 #define YY_CURRENT_BUFFER yy_current_buffer
232
233
234 /* yy_hold_char holds the character lost when yytext is formed. */
235 static char yy_hold_char;
236
237 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
238
239
240 int yyleng;
241
242 /* Points to current character in buffer. */
243 static char *yy_c_buf_p = (char *) 0;
244 static int yy_init = 1;         /* whether we need to initialize */
245 static int yy_start = 0;        /* start state number */
246
247 /* Flag which is used to allow yywrap()'s to do buffer switches
248  * instead of setting up a fresh yyin.  A bit of a hack ...
249  */
250 static int yy_did_buffer_switch_on_eof;
251
252 void yyrestart YY_PROTO(( FILE *input_file ));
253
254 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
255 void yy_load_buffer_state YY_PROTO(( void ));
256 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
257 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
258 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
259 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
260 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
261
262 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
263 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
264 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
265
266 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
267 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
268 static void yy_flex_free YY_PROTO(( void * ));
269
270 #define yy_new_buffer yy_create_buffer
271
272 #define yy_set_interactive(is_interactive) \
273         { \
274         if ( ! yy_current_buffer ) \
275                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
276         yy_current_buffer->yy_is_interactive = is_interactive; \
277         }
278
279 #define yy_set_bol(at_bol) \
280         { \
281         if ( ! yy_current_buffer ) \
282                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
283         yy_current_buffer->yy_at_bol = at_bol; \
284         }
285
286 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
287
288
289 #define YY_USES_REJECT
290 typedef unsigned char YY_CHAR;
291 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
292 typedef int yy_state_type;
293 extern char *yytext;
294 #define yytext_ptr yytext
295
296 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
297 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
298 static int yy_get_next_buffer YY_PROTO(( void ));
299 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
300
301 /* Done after the current pattern has been matched and before the
302  * corresponding action - sets up yytext.
303  */
304 #define YY_DO_BEFORE_ACTION \
305         yytext_ptr = yy_bp; \
306         yyleng = (int) (yy_cp - yy_bp); \
307         yy_hold_char = *yy_cp; \
308         *yy_cp = '\0'; \
309         yy_c_buf_p = yy_cp;
310
311 #define YY_NUM_RULES 37
312 #define YY_END_OF_BUFFER 38
313 static yyconst short int yy_acclist[146] =
314     {   0,
315        38,   36,   37,    1,   36,   37,    3,   36,   37,    4,
316        36,   37,    2,   36,   37,   36,   37,   36,   37,   36,
317        37,   18,   36,   37,   36,   37,   36,   37,   15,   36,
318        37,   16,   37,   36,   37,    9,   36,   37,   17,   36,
319        37,   36,   37,   31,   36,   37,    9,   34,   36,   37,
320        20,   36,   37,   19,   36,   37,   34,   36,   37,   34,
321        36,   37,   34,   36,   37,   34,   36,   37,   34,   36,
322        37,   34,   36,   37,    5,   36,   37,   35,    8,16391,
323        12,   22,   10,    9,   10,   10,   21,    9,   10,   34,
324        34,   34,   34,   34,   34,   34,    5,   13,    6, 8199,
325
326        10,   14,   14,   34,   34,   34,   34,   34,   34, 8199,
327        11,   11,   11,   34,   34,   34,   34,   34,   30,   34,
328        11,   11,   11,   34,   26,   34,   34,   34,   34,   23,
329        32,   34,   34,   34,   34,   34,   25,   34,   24,   29,
330        33,   34,   27,   28,   28
331     } ;
332
333 static yyconst short int yy_accept[109] =
334     {   0,
335         1,    1,    1,    2,    4,    7,   10,   13,   16,   18,
336        20,   22,   25,   27,   29,   32,   34,   36,   39,   42,
337        44,   47,   51,   54,   57,   60,   63,   66,   69,   72,
338        75,   78,   79,   79,   81,   81,   81,   81,   82,   83,
339        84,   86,   87,   87,   88,   91,   92,   93,   94,   95,
340        96,   97,   98,   99,   99,  101,  101,  101,  103,  103,
341       104,  105,  106,  107,  108,  109,  110,  111,  111,  112,
342       113,  115,  116,  116,  117,  118,  118,  119,  120,  121,
343       121,  122,  123,  125,  126,  126,  127,  128,  129,  130,
344       131,  132,  132,  133,  134,  135,  136,  136,  137,  138,
345
346       139,  140,  140,  141,  143,  145,  146,  146
347     } ;
348
349 static yyconst int yy_ec[256] =
350     {   0,
351         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
352         4,    4,    5,    4,    4,    4,    4,    4,    4,    4,
353         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
354         4,    6,    7,    8,    9,   10,    4,   11,   12,   13,
355        14,   15,   16,   17,   18,   19,   20,   21,   21,   21,
356        21,   21,   21,   21,   21,   21,   21,    4,   22,    4,
357        23,    4,    4,    4,   24,   25,   26,   27,   28,   25,
358        29,   30,   31,   29,   29,   29,   29,   32,   33,   34,
359        29,   35,   36,   37,   29,   29,   29,   29,   29,   29,
360         4,    4,    4,    4,   29,    4,   38,   38,   38,   38,
361
362        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
363        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
364        38,   38,    4,    4,    4,    4,    1,    1,    4,    4,
365         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
366         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
367         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
368         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
369         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
370         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
371         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
372
373         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
374         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
375         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
376         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
377         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
378         4,    4,    4,    4,    4
379     } ;
380
381 static yyconst int yy_meta[40] =
382     {   0,
383         1,    2,    3,    2,    2,    2,    2,    2,    2,    2,
384         2,    2,    2,    2,    2,    2,    2,    2,    4,    2,
385         5,    2,    2,    5,    5,    5,    5,    5,    6,    6,
386         6,    6,    6,    6,    6,    6,    6,    7,    2
387     } ;
388
389 static yyconst short int yy_base[114] =
390     {   0,
391         0,    0,  209,  210,  210,  210,  210,  210,    0,    0,
392       187,  210,  171,   37,  210,  210,  186,   22,  210,   23,
393       190,   26,  210,  210,  185,   27,   29,   31,   33,   34,
394       164,    0,  194,   52,  175,   52,   53,  188,  210,   49,
395        53,   57,  180,  210,   61,  179,   47,   60,   38,   64,
396        67,  158,  210,   86,  210,  163,   75,   79,   83,  210,
397        87,   91,   93,   94,   98,   99,  210,  161,  173,  103,
398       104,   41,  158,  108,  107,  110,    0,  210,  118,  139,
399       144,  120,  123,  210,  125,  119,  124,  127,   95,  210,
400       210,   61,  128,  129,  130,  134,  136,  140,  210,  141,
401
402       210,  148,  210,   71,    0,    0,  210,  166,   62,  172,
403       176,  179,  186
404     } ;
405
406 static yyconst short int yy_def[114] =
407     {   0,
408       107,    1,  107,  107,  107,  107,  107,  107,  108,  109,
409       107,  107,  107,  110,  107,  107,  107,  107,  107,  111,
410       107,  112,  107,  107,  112,  112,  112,  112,  112,  112,
411       107,  108,  109,  107,  107,  110,  110,  107,  107,  107,
412       107,  111,  111,  107,  112,  112,  112,  112,  112,  112,
413       112,  107,  107,  107,  107,  107,  107,  107,  111,  107,
414       112,  112,  112,  112,  112,  112,  107,  107,  107,  111,
415       112,  112,  107,  112,  112,  107,   65,  107,  112,  107,
416       107,  111,  112,  107,  107,  112,  112,  112,  112,  107,
417       107,  107,  112,  112,  112,  112,  107,  112,  107,  112,
418
419       107,  107,  107,  112,  113,  113,    0,  107,  107,  107,
420       107,  107,  107
421     } ;
422
423 static yyconst short int yy_nxt[250] =
424     {   0,
425         4,    5,    6,    4,    7,    8,    9,   10,   11,   12,
426        13,   14,   15,   16,   17,   18,   19,   18,   20,   21,
427        22,   23,   24,   25,   25,   25,   26,   27,   25,   28,
428        29,   25,   25,   25,   25,   30,   25,   25,   31,   37,
429        40,   40,   41,   42,   40,  107,   45,  107,   38,  107,
430        47,  107,  107,   54,   37,   37,  107,   54,   49,  107,
431        48,   64,   84,   38,   38,  107,   33,   40,   50,   40,
432        51,   40,   34,   41,   55,   58,   57,   42,  107,   40,
433        57,   45,  107,   62,   59,  107,   63,   54,   61,  107,
434        69,   54,   69,   97,   66,   69,   65,   40,   69,   40,
435
436        69,   60,   69,   70,   69,  107,   57,   71,   67,  107,
437        73,  107,  107,  107,   72,   76,  107,  107,   77,   78,
438        75,   60,  107,   82,   83,  107,  107,   76,   74,   96,
439        76,   78,   79,   86,   89,   87,  107,  107,   60,   90,
440        82,  107,  107,   83,   88,  107,  107,  107,  107,   94,
441        99,   93,  107,  102,   95,  101,  102,  103,  107,  107,
442        92,   98,  105,  100,   81,  102,   91,  104,  102,  103,
443        32,   32,   32,   36,   36,   36,   36,   36,   36,   43,
444        43,   43,   46,   46,   46,   46,  106,  106,   85,  106,
445       106,  106,  106,   81,   80,   68,   52,  107,   60,   36,
446
447        56,   53,   52,  107,   44,   39,   35,   34,  107,    3,
448       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
449       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
450       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
451       107,  107,  107,  107,  107,  107,  107,  107,  107
452     } ;
453
454 static yyconst short int yy_chk[250] =
455     {   0,
456         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
457         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
458         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
459         1,    1,    1,    1,    1,    1,    1,    1,    1,   14,
460        18,   20,   18,   20,   22,   26,   22,   27,   14,   28,
461        26,   29,   30,   34,   36,   37,   49,   34,   28,   72,
462        27,   49,   72,   36,   37,   47,  109,   40,   29,   40,
463        30,   41,   34,   41,   34,   42,   40,   42,   48,   45,
464        41,   45,   50,   47,   42,   51,   48,   54,   45,  104,
465        57,   54,   57,   92,   51,   57,   50,   58,   59,   58,
466
467        59,   59,   61,   59,   61,   61,   58,   61,   54,   62,
468        63,   63,   64,   89,   62,   65,   65,   66,   65,   65,
469        64,   70,   71,   70,   71,   75,   74,   76,   63,   89,
470        76,   76,   66,   74,   75,   74,   79,   86,   82,   79,
471        82,   83,   87,   83,   74,   88,   93,   94,   95,   87,
472        94,   86,   96,   97,   88,   96,   97,   97,   98,  100,
473        85,   93,  100,   95,   81,  102,   80,   98,  102,  102,
474       108,  108,  108,  110,  110,  110,  110,  110,  110,  111,
475       111,  111,  112,  112,  112,  112,  113,  113,   73,  113,
476       113,  113,  113,   69,   68,   56,   52,   46,   43,   38,
477
478        35,   33,   31,   25,   21,   17,   13,   11,    3,  107,
479       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
480       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
481       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
482       107,  107,  107,  107,  107,  107,  107,  107,  107
483     } ;
484
485 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
486 static char *yy_full_match;
487 static int yy_lp;
488 static int yy_looking_for_trail_begin = 0;
489 static int yy_full_lp;
490 static int *yy_full_state;
491 #define YY_TRAILING_MASK 0x2000
492 #define YY_TRAILING_HEAD_MASK 0x4000
493 #define REJECT \
494 { \
495 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
496 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
497 yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \
498 yy_state_ptr = yy_full_state; /* restore orig. state */ \
499 yy_current_state = *yy_state_ptr; /* restore curr. state */ \
500 ++yy_lp; \
501 goto find_rule; \
502 }
503 #define yymore() yymore_used_but_not_detected
504 #define YY_MORE_ADJ 0
505 #define YY_RESTORE_YY_MORE_OFFSET
506 char *yytext;
507 #define INITIAL 0
508 /* 
509  Copyright (c) 1999-2014 OPEN CASCADE SAS
510
511  This file is part of Open CASCADE Technology software library.
512
513  This library is free software; you can redistribute it and/or modify it under
514  the terms of the GNU Lesser General Public License version 2.1 as published
515  by the Free Software Foundation, with special exception defined in the file
516  OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
517  distribution for complete text of the license and disclaimer of any warranty.
518
519  Alternatively, this file may be used under the terms of Open CASCADE
520  commercial license or contractual agreement.
521 */ 
522 #include "step.tab.h"
523 #include "recfile.ph"
524 #include "stdio.h"
525 #include <StepFile_CallFailure.hxx>
526
527 /* skl 31.01.2002 for OCC133(OCC96,97) - uncorrect
528 long string in files Henri.stp and 401.stp*/
529 #define YY_FATAL_ERROR(msg) StepFile_CallFailure( msg )
530
531 /* abv 07.06.02: force inclusion of stdlib.h on WNT to avoid warnings */
532 #include <stdlib.h>
533
534 /*
535 void steperror ( FILE *input_file );
536 void steprestart ( FILE *input_file );
537 */
538 void rec_restext(char *newtext, int lentext);
539 void rec_typarg(int argtype);
540  
541   int  steplineno;      /* Comptage de ligne (ben oui, fait tout faire)  */
542
543   int  modcom = 0;      /* Commentaires type C */
544   int  modend = 0;      /* Flag for finishing of the STEP file */
545   void resultat ()           /* Resultat alloue dynamiquement, "jete" une fois lu */
546       { if (modcom == 0) rec_restext(yytext,yyleng); }
547
548 // MSVC specifics
549 #ifdef _MSC_VER
550
551 // disable MSVC warnings in flex code
552 // Note that Intel compiler also defines _MSC_VER but has different warning ids
553 #if defined(__INTEL_COMPILER)
554 #pragma warning(disable:177 1786 1736)
555 #elif defined(__clang__)
556 #pragma GCC diagnostic ignored "-Wunused-function"
557 #pragma GCC diagnostic ignored "-Winconsistent-dllimport"
558 #pragma GCC diagnostic ignored "-Wunneeded-internal-declaration"
559 #else
560 #pragma warning(disable:4131 4244 4273 4267 4127)
561 #endif
562
563 // Avoid includion of unistd.h if parser is generated on Linux (flex 2.5.35)
564 #define YY_NO_UNISTD_H
565
566 #endif
567
568 // disable GCC warnings in flex code
569 #ifdef __GNUC__
570 #pragma GCC diagnostic ignored "-Wunused-function"
571 #endif
572
573
574 /* Macros after this point can all be overridden by user definitions in
575  * section 1.
576  */
577
578 #ifndef YY_SKIP_YYWRAP
579 #ifdef __cplusplus
580 extern "C" int yywrap YY_PROTO(( void ));
581 #else
582 extern int yywrap YY_PROTO(( void ));
583 #endif
584 #endif
585
586 #ifndef YY_NO_UNPUT
587 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
588 #endif
589
590 #ifndef yytext_ptr
591 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
592 #endif
593
594 #ifdef YY_NEED_STRLEN
595 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
596 #endif
597
598 #ifndef YY_NO_INPUT
599 #ifdef __cplusplus
600 static int yyinput YY_PROTO(( void ));
601 #else
602 static int input YY_PROTO(( void ));
603 #endif
604 #endif
605
606 #if YY_STACK_USED
607 static int yy_start_stack_ptr = 0;
608 static int yy_start_stack_depth = 0;
609 static int *yy_start_stack = 0;
610 #ifndef YY_NO_PUSH_STATE
611 static void yy_push_state YY_PROTO(( int new_state ));
612 #endif
613 #ifndef YY_NO_POP_STATE
614 static void yy_pop_state YY_PROTO(( void ));
615 #endif
616 #ifndef YY_NO_TOP_STATE
617 static int yy_top_state YY_PROTO(( void ));
618 #endif
619
620 #else
621 #define YY_NO_PUSH_STATE 1
622 #define YY_NO_POP_STATE 1
623 #define YY_NO_TOP_STATE 1
624 #endif
625
626 #ifdef YY_MALLOC_DECL
627 YY_MALLOC_DECL
628 #else
629 #if __STDC__
630 #ifndef __cplusplus
631 #include <stdlib.h>
632 #endif
633 #else
634 /* Just try to get by without declaring the routines.  This will fail
635  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
636  * or sizeof(void*) != sizeof(int).
637  */
638 #endif
639 #endif
640
641 /* Amount of stuff to slurp up with each read. */
642 #ifndef YY_READ_BUF_SIZE
643 #define YY_READ_BUF_SIZE 8192
644 #endif
645
646 /* Copy whatever the last rule matched to the standard output. */
647
648 #ifndef ECHO
649 /* This used to be an fputs(), but since the string might contain NUL's,
650  * we now use fwrite().
651  */
652 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
653 #endif
654
655 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
656  * is returned in "result".
657  */
658 #ifndef YY_INPUT
659 #define YY_INPUT(buf,result,max_size) \
660         if ( yy_current_buffer->yy_is_interactive ) \
661                 { \
662                 int c = '*', n; \
663                 for ( n = 0; n < max_size && \
664                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
665                         buf[n] = (char) c; \
666                 if ( c == '\n' ) \
667                         buf[n++] = (char) c; \
668                 if ( c == EOF && ferror( yyin ) ) \
669                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
670                 result = n; \
671                 } \
672         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
673                   && ferror( yyin ) ) \
674                 YY_FATAL_ERROR( "input in flex scanner failed" );
675 #endif
676
677 /* No semi-colon after return; correct usage is to write "yyterminate();" -
678  * we don't want an extra ';' after the "return" because that will cause
679  * some compilers to complain about unreachable statements.
680  */
681 #ifndef yyterminate
682 #define yyterminate() return YY_NULL
683 #endif
684
685 /* Number of entries by which start-condition stack grows. */
686 #ifndef YY_START_STACK_INCR
687 #define YY_START_STACK_INCR 25
688 #endif
689
690 /* Report a fatal error. */
691 #ifndef YY_FATAL_ERROR
692 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
693 #endif
694
695 /* Default declaration of generated scanner - a define so the user can
696  * easily add parameters.
697  */
698 #ifndef YY_DECL
699 #define YY_DECL int yylex YY_PROTO(( void ))
700 #endif
701
702 /* Code executed at the beginning of each rule, after yytext and yyleng
703  * have been set up.
704  */
705 #ifndef YY_USER_ACTION
706 #define YY_USER_ACTION
707 #endif
708
709 /* Code executed at the end of each rule. */
710 #ifndef YY_BREAK
711 #define YY_BREAK break;
712 #endif
713
714 #define YY_RULE_SETUP \
715         YY_USER_ACTION
716
717 YY_DECL
718         {
719         register yy_state_type yy_current_state;
720         register char *yy_cp, *yy_bp;
721         register int yy_act;
722
723
724
725         if ( yy_init )
726                 {
727                 yy_init = 0;
728
729 #ifdef YY_USER_INIT
730                 YY_USER_INIT;
731 #endif
732
733                 if ( ! yy_start )
734                         yy_start = 1;   /* first start state */
735
736                 if ( ! yyin )
737                         yyin = stdin;
738
739                 if ( ! yyout )
740                         yyout = stdout;
741
742                 if ( ! yy_current_buffer )
743                         yy_current_buffer =
744                                 yy_create_buffer( yyin, YY_BUF_SIZE );
745
746                 yy_load_buffer_state();
747                 }
748
749         while ( 1 )             /* loops until end-of-file is reached */
750                 {
751                 yy_cp = yy_c_buf_p;
752
753                 /* Support of yytext. */
754                 *yy_cp = yy_hold_char;
755
756                 /* yy_bp points to the position in yy_ch_buf of the start of
757                  * the current run.
758                  */
759                 yy_bp = yy_cp;
760
761                 yy_current_state = yy_start;
762                 yy_state_ptr = yy_state_buf;
763                 *yy_state_ptr++ = yy_current_state;
764 yy_match:
765                 do
766                         {
767                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
768                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
769                                 {
770                                 yy_current_state = (int) yy_def[yy_current_state];
771                                 if ( yy_current_state >= 108 )
772                                         yy_c = yy_meta[(unsigned int) yy_c];
773                                 }
774                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
775                         *yy_state_ptr++ = yy_current_state;
776                         ++yy_cp;
777                         }
778                 while ( yy_base[yy_current_state] != 210 );
779
780 yy_find_action:
781                 yy_current_state = *--yy_state_ptr;
782                 yy_lp = yy_accept[yy_current_state];
783 find_rule: /* we branch to this label when backing up */
784                 for ( ; ; ) /* until we find what rule we matched */
785                         {
786                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
787                                 {
788                                 yy_act = yy_acclist[yy_lp];
789                                 if ( yy_act & YY_TRAILING_HEAD_MASK ||
790                                      yy_looking_for_trail_begin )
791                                         {
792                                         if ( yy_act == yy_looking_for_trail_begin )
793                                                 {
794                                                 yy_looking_for_trail_begin = 0;
795                                                 yy_act &= ~YY_TRAILING_HEAD_MASK;
796                                                 break;
797                                                 }
798                                         }
799                                 else if ( yy_act & YY_TRAILING_MASK )
800                                         {
801                                         yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
802                                         yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
803                                         }
804                                 else
805                                         {
806                                         yy_full_match = yy_cp;
807                                         yy_full_state = yy_state_ptr;
808                                         yy_full_lp = yy_lp;
809                                         break;
810                                         }
811                                 ++yy_lp;
812                                 goto find_rule;
813                                 }
814                         --yy_cp;
815                         yy_current_state = *--yy_state_ptr;
816                         yy_lp = yy_accept[yy_current_state];
817                         }
818
819                 YY_DO_BEFORE_ACTION;
820
821
822 do_action:      /* This label is used only to access EOF actions. */
823
824
825                 switch ( yy_act )
826         { /* beginning of action switch */
827 case 1:
828 YY_RULE_SETUP
829 {;}
830         YY_BREAK
831 case 2:
832 YY_RULE_SETUP
833 {;}
834         YY_BREAK
835 case 3:
836 YY_RULE_SETUP
837 { steplineno ++; }
838         YY_BREAK
839 case 4:
840 YY_RULE_SETUP
841 {;} /* abv 30.06.00: for reading DOS files */
842         YY_BREAK
843 case 5:
844 YY_RULE_SETUP
845 {;} /* fix from C21. for test load e3i file with line 15 with null symbols */
846         YY_BREAK
847 case 6:
848 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
849 yy_c_buf_p = yy_cp -= 1;
850 YY_DO_BEFORE_ACTION; /* set up yytext again */
851 YY_RULE_SETUP
852 { resultat();  if (modcom == 0) return(ENTITY); }
853         YY_BREAK
854 case 7:
855 YY_RULE_SETUP
856 { resultat();  if (modcom == 0) return(ENTITY); }
857         YY_BREAK
858 case 8:
859 YY_RULE_SETUP
860 { resultat();  if (modcom == 0) return(IDENT); }
861         YY_BREAK
862 case 9:
863 YY_RULE_SETUP
864 { resultat();  if (modcom == 0) { rec_typarg(rec_argInteger); return(QUID); } }
865         YY_BREAK
866 case 10:
867 YY_RULE_SETUP
868 { resultat();  if (modcom == 0) { rec_typarg(rec_argFloat); return(QUID); } }
869         YY_BREAK
870 case 11:
871 YY_RULE_SETUP
872 { resultat(); if (modcom == 0) { rec_typarg(rec_argFloat); return(QUID); } }
873         YY_BREAK
874 case 12:
875 YY_RULE_SETUP
876 { resultat(); if (modcom == 0) { rec_typarg(rec_argText); return(QUID); } }
877         YY_BREAK
878 case 13:
879 YY_RULE_SETUP
880 { resultat();  if (modcom == 0) { rec_typarg(rec_argHexa); return(QUID); } }
881         YY_BREAK
882 case 14:
883 YY_RULE_SETUP
884 { resultat();  if (modcom == 0) { rec_typarg(rec_argEnum); return(QUID); } }
885         YY_BREAK
886 case 15:
887 YY_RULE_SETUP
888 { if (modcom == 0) return ('('); }
889         YY_BREAK
890 case 16:
891 YY_RULE_SETUP
892 { if (modcom == 0) return (')'); }
893         YY_BREAK
894 case 17:
895 YY_RULE_SETUP
896 { if (modcom == 0) return (','); }
897         YY_BREAK
898 case 18:
899 YY_RULE_SETUP
900 { resultat();  if (modcom == 0) { rec_typarg(rec_argNondef); return(QUID); } }
901         YY_BREAK
902 case 19:
903 YY_RULE_SETUP
904 { if (modcom == 0) return ('='); }
905         YY_BREAK
906 case 20:
907 YY_RULE_SETUP
908 { if (modcom == 0) return (';'); }
909         YY_BREAK
910 case 21:
911 YY_RULE_SETUP
912 { modcom = 1;  }
913         YY_BREAK
914 case 22:
915 YY_RULE_SETUP
916 { if (modend == 0) modcom = 0;  }
917         YY_BREAK
918 case 23:
919 YY_RULE_SETUP
920 { if (modcom == 0) return(STEP); }
921         YY_BREAK
922 case 24:
923 YY_RULE_SETUP
924 { if (modcom == 0) return(HEADER); }
925         YY_BREAK
926 case 25:
927 YY_RULE_SETUP
928 { if (modcom == 0) return(ENDSEC); }
929         YY_BREAK
930 case 26:
931 YY_RULE_SETUP
932 { if (modcom == 0) return(DATA); }
933         YY_BREAK
934 case 27:
935 YY_RULE_SETUP
936 { if (modend == 0) {modcom = 0;  return(ENDSTEP);} }
937         YY_BREAK
938 case 28:
939 YY_RULE_SETUP
940 { if (modend == 0) {modcom = 0;  return(ENDSTEP);} }
941         YY_BREAK
942 case 29:
943 YY_RULE_SETUP
944 { modcom = 1; modend = 1; return(ENDSTEP); }
945         YY_BREAK
946 case 30:
947 YY_RULE_SETUP
948 { if (modend == 0) {modcom = 0;  return(STEP); } }
949         YY_BREAK
950 case 31:
951 YY_RULE_SETUP
952 { if (modcom == 0) return ('/'); }
953         YY_BREAK
954 case 32:
955 YY_RULE_SETUP
956 { if (modcom == 0) return(SCOPE); }
957         YY_BREAK
958 case 33:
959 YY_RULE_SETUP
960 { if (modcom == 0) return(ENDSCOPE); }
961         YY_BREAK
962 case 34:
963 YY_RULE_SETUP
964 { resultat();  if (modcom == 0) return(TYPE); }
965         YY_BREAK
966 case 35:
967 YY_RULE_SETUP
968 { resultat();  if (modcom == 0) return(TYPE); }
969         YY_BREAK
970 case 36:
971 YY_RULE_SETUP
972 { resultat();  if (modcom == 0) { rec_typarg(rec_argMisc); return(QUID); } }
973         YY_BREAK
974 case 37:
975 YY_RULE_SETUP
976 ECHO;
977         YY_BREAK
978                         case YY_STATE_EOF(INITIAL):
979                                 yyterminate();
980
981         case YY_END_OF_BUFFER:
982                 {
983                 /* Amount of text matched not including the EOB char. */
984                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
985
986                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
987                 *yy_cp = yy_hold_char;
988                 YY_RESTORE_YY_MORE_OFFSET
989
990                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
991                         {
992                         /* We're scanning a new file or input source.  It's
993                          * possible that this happened because the user
994                          * just pointed yyin at a new source and called
995                          * yylex().  If so, then we have to assure
996                          * consistency between yy_current_buffer and our
997                          * globals.  Here is the right place to do so, because
998                          * this is the first action (other than possibly a
999                          * back-up) that will match for the new input source.
1000                          */
1001                         yy_n_chars = yy_current_buffer->yy_n_chars;
1002                         yy_current_buffer->yy_input_file = yyin;
1003                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1004                         }
1005
1006                 /* Note that here we test for yy_c_buf_p "<=" to the position
1007                  * of the first EOB in the buffer, since yy_c_buf_p will
1008                  * already have been incremented past the NUL character
1009                  * (since all states make transitions on EOB to the
1010                  * end-of-buffer state).  Contrast this with the test
1011                  * in input().
1012                  */
1013                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1014                         { /* This was really a NUL. */
1015                         yy_state_type yy_next_state;
1016
1017                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1018
1019                         yy_current_state = yy_get_previous_state();
1020
1021                         /* Okay, we're now positioned to make the NUL
1022                          * transition.  We couldn't have
1023                          * yy_get_previous_state() go ahead and do it
1024                          * for us because it doesn't know how to deal
1025                          * with the possibility of jamming (and we don't
1026                          * want to build jamming into it because then it
1027                          * will run more slowly).
1028                          */
1029
1030                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1031
1032                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1033
1034                         if ( yy_next_state )
1035                                 {
1036                                 /* Consume the NUL. */
1037                                 yy_cp = ++yy_c_buf_p;
1038                                 yy_current_state = yy_next_state;
1039                                 goto yy_match;
1040                                 }
1041
1042                         else
1043                                 {
1044                                 yy_cp = yy_c_buf_p;
1045                                 goto yy_find_action;
1046                                 }
1047                         }
1048
1049                 else switch ( yy_get_next_buffer() )
1050                         {
1051                         case EOB_ACT_END_OF_FILE:
1052                                 {
1053                                 yy_did_buffer_switch_on_eof = 0;
1054
1055                                 if ( yywrap() )
1056                                         {
1057                                         /* Note: because we've taken care in
1058                                          * yy_get_next_buffer() to have set up
1059                                          * yytext, we can now set up
1060                                          * yy_c_buf_p so that if some total
1061                                          * hoser (like flex itself) wants to
1062                                          * call the scanner after we return the
1063                                          * YY_NULL, it'll still work - another
1064                                          * YY_NULL will get returned.
1065                                          */
1066                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1067
1068                                         yy_act = YY_STATE_EOF(YY_START);
1069                                         goto do_action;
1070                                         }
1071
1072                                 else
1073                                         {
1074                                         if ( ! yy_did_buffer_switch_on_eof )
1075                                                 YY_NEW_FILE;
1076                                         }
1077                                 break;
1078                                 }
1079
1080                         case EOB_ACT_CONTINUE_SCAN:
1081                                 yy_c_buf_p =
1082                                         yytext_ptr + yy_amount_of_matched_text;
1083
1084                                 yy_current_state = yy_get_previous_state();
1085
1086                                 yy_cp = yy_c_buf_p;
1087                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1088                                 goto yy_match;
1089
1090                         case EOB_ACT_LAST_MATCH:
1091                                 yy_c_buf_p =
1092                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1093
1094                                 yy_current_state = yy_get_previous_state();
1095
1096                                 yy_cp = yy_c_buf_p;
1097                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1098                                 goto yy_find_action;
1099                         }
1100                 break;
1101                 }
1102
1103         default:
1104                 YY_FATAL_ERROR(
1105                         "fatal flex scanner internal error--no action found" );
1106         } /* end of action switch */
1107                 } /* end of scanning one token */
1108         } /* end of yylex */
1109
1110
1111 /* yy_get_next_buffer - try to read in a new buffer
1112  *
1113  * Returns a code representing an action:
1114  *      EOB_ACT_LAST_MATCH -
1115  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1116  *      EOB_ACT_END_OF_FILE - end of file
1117  */
1118
1119 static int yy_get_next_buffer()
1120         {
1121         register char *dest = yy_current_buffer->yy_ch_buf;
1122         register char *source = yytext_ptr;
1123         register int number_to_move, i;
1124         int ret_val;
1125
1126         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1127                 YY_FATAL_ERROR(
1128                 "fatal flex scanner internal error--end of buffer missed" );
1129
1130         if ( yy_current_buffer->yy_fill_buffer == 0 )
1131                 { /* Don't try to fill the buffer, so this is an EOF. */
1132                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1133                         {
1134                         /* We matched a single character, the EOB, so
1135                          * treat this as a final EOF.
1136                          */
1137                         return EOB_ACT_END_OF_FILE;
1138                         }
1139
1140                 else
1141                         {
1142                         /* We matched some text prior to the EOB, first
1143                          * process it.
1144                          */
1145                         return EOB_ACT_LAST_MATCH;
1146                         }
1147                 }
1148
1149         /* Try to read more data. */
1150
1151         /* First move last chars to start of buffer. */
1152         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1153
1154         for ( i = 0; i < number_to_move; ++i )
1155                 *(dest++) = *(source++);
1156
1157         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1158                 /* don't do the read, it's not guaranteed to return an EOF,
1159                  * just force an EOF
1160                  */
1161                 yy_n_chars = 0;
1162
1163         else
1164                 {
1165                 int num_to_read =
1166                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1167
1168                 while ( num_to_read <= 0 )
1169                         { /* Not enough room in the buffer - grow it. */
1170 #ifdef YY_USES_REJECT
1171                         YY_FATAL_ERROR(
1172 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1173 #else
1174
1175                         /* just a shorter name for the current buffer */
1176                         YY_BUFFER_STATE b = yy_current_buffer;
1177
1178                         int yy_c_buf_p_offset =
1179                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1180
1181                         if ( b->yy_is_our_buffer )
1182                                 {
1183                                 int new_size = b->yy_buf_size * 2;
1184
1185                                 if ( new_size <= 0 )
1186                                         b->yy_buf_size += b->yy_buf_size / 8;
1187                                 else
1188                                         b->yy_buf_size *= 2;
1189
1190                                 b->yy_ch_buf = (char *)
1191                                         /* Include room in for 2 EOB chars. */
1192                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1193                                                          b->yy_buf_size + 2 );
1194                                 }
1195                         else
1196                                 /* Can't grow it, we don't own it. */
1197                                 b->yy_ch_buf = 0;
1198
1199                         if ( ! b->yy_ch_buf )
1200                                 YY_FATAL_ERROR(
1201                                 "fatal error - scanner input buffer overflow" );
1202
1203                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1204
1205                         num_to_read = yy_current_buffer->yy_buf_size -
1206                                                 number_to_move - 1;
1207 #endif
1208                         }
1209
1210                 if ( num_to_read > YY_READ_BUF_SIZE )
1211                         num_to_read = YY_READ_BUF_SIZE;
1212
1213                 /* Read in more data. */
1214                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1215                         yy_n_chars, num_to_read );
1216                 }
1217
1218         if ( yy_n_chars == 0 )
1219                 {
1220                 if ( number_to_move == YY_MORE_ADJ )
1221                         {
1222                         ret_val = EOB_ACT_END_OF_FILE;
1223                         yyrestart( yyin );
1224                         }
1225
1226                 else
1227                         {
1228                         ret_val = EOB_ACT_LAST_MATCH;
1229                         yy_current_buffer->yy_buffer_status =
1230                                 YY_BUFFER_EOF_PENDING;
1231                         }
1232                 }
1233
1234         else
1235                 ret_val = EOB_ACT_CONTINUE_SCAN;
1236
1237         yy_n_chars += number_to_move;
1238         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1239         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1240
1241         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1242
1243         return ret_val;
1244         }
1245
1246
1247 /* yy_get_previous_state - get the state just before the EOB char was reached */
1248
1249 static yy_state_type yy_get_previous_state()
1250         {
1251         register yy_state_type yy_current_state;
1252         register char *yy_cp;
1253
1254         yy_current_state = yy_start;
1255         yy_state_ptr = yy_state_buf;
1256         *yy_state_ptr++ = yy_current_state;
1257
1258         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1259                 {
1260                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 39);
1261                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1262                         {
1263                         yy_current_state = (int) yy_def[yy_current_state];
1264                         if ( yy_current_state >= 108 )
1265                                 yy_c = yy_meta[(unsigned int) yy_c];
1266                         }
1267                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1268                 *yy_state_ptr++ = yy_current_state;
1269                 }
1270
1271         return yy_current_state;
1272         }
1273
1274
1275 /* yy_try_NUL_trans - try to make a transition on the NUL character
1276  *
1277  * synopsis
1278  *      next_state = yy_try_NUL_trans( current_state );
1279  */
1280
1281 #ifdef YY_USE_PROTOS
1282 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1283 #else
1284 static yy_state_type yy_try_NUL_trans( yy_current_state )
1285 yy_state_type yy_current_state;
1286 #endif
1287         {
1288         register int yy_is_jam;
1289
1290         register YY_CHAR yy_c = 39;
1291         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1292                 {
1293                 yy_current_state = (int) yy_def[yy_current_state];
1294                 if ( yy_current_state >= 108 )
1295                         yy_c = yy_meta[(unsigned int) yy_c];
1296                 }
1297         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1298         yy_is_jam = (yy_current_state == 107);
1299         if ( ! yy_is_jam )
1300                 *yy_state_ptr++ = yy_current_state;
1301
1302         return yy_is_jam ? 0 : yy_current_state;
1303         }
1304
1305
1306 #ifndef YY_NO_UNPUT
1307 #ifdef YY_USE_PROTOS
1308 static void yyunput( int c, register char *yy_bp )
1309 #else
1310 static void yyunput( c, yy_bp )
1311 int c;
1312 register char *yy_bp;
1313 #endif
1314         {
1315         register char *yy_cp = yy_c_buf_p;
1316
1317         /* undo effects of setting up yytext */
1318         *yy_cp = yy_hold_char;
1319
1320         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1321                 { /* need to shift things up to make room */
1322                 /* +2 for EOB chars. */
1323                 register int number_to_move = yy_n_chars + 2;
1324                 register char *dest = &yy_current_buffer->yy_ch_buf[
1325                                         yy_current_buffer->yy_buf_size + 2];
1326                 register char *source =
1327                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1328
1329                 while ( source > yy_current_buffer->yy_ch_buf )
1330                         *--dest = *--source;
1331
1332                 yy_cp += (int) (dest - source);
1333                 yy_bp += (int) (dest - source);
1334                 yy_n_chars = yy_current_buffer->yy_buf_size;
1335
1336                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1337                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1338                 }
1339
1340         *--yy_cp = (char) c;
1341
1342
1343         yytext_ptr = yy_bp;
1344         yy_hold_char = *yy_cp;
1345         yy_c_buf_p = yy_cp;
1346         }
1347 #endif  /* ifndef YY_NO_UNPUT */
1348
1349
1350 #ifdef __cplusplus
1351 static int yyinput()
1352 #else
1353 static int input()
1354 #endif
1355         {
1356         int c;
1357
1358         *yy_c_buf_p = yy_hold_char;
1359
1360         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1361                 {
1362                 /* yy_c_buf_p now points to the character we want to return.
1363                  * If this occurs *before* the EOB characters, then it's a
1364                  * valid NUL; if not, then we've hit the end of the buffer.
1365                  */
1366                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1367                         /* This was really a NUL. */
1368                         *yy_c_buf_p = '\0';
1369
1370                 else
1371                         { /* need more input */
1372                         int offset = yy_c_buf_p - yytext_ptr;
1373                         ++yy_c_buf_p;
1374
1375                         switch ( yy_get_next_buffer() )
1376                                 {
1377                                 case EOB_ACT_END_OF_FILE:
1378                                         {
1379                                         if ( yywrap() )
1380                                                 {
1381                                                 yy_c_buf_p = yytext_ptr + offset;
1382                                                 return EOF;
1383                                                 }
1384
1385                                         if ( ! yy_did_buffer_switch_on_eof )
1386                                                 YY_NEW_FILE;
1387 #ifdef __cplusplus
1388                                         return yyinput();
1389 #else
1390                                         return input();
1391 #endif
1392                                         }
1393
1394                                 case EOB_ACT_CONTINUE_SCAN:
1395                                         yy_c_buf_p = yytext_ptr + offset;
1396                                         break;
1397
1398                                 case EOB_ACT_LAST_MATCH:
1399 #ifdef __cplusplus
1400                                         YY_FATAL_ERROR(
1401                                         "unexpected last match in yyinput()" );
1402 #else
1403                                         YY_FATAL_ERROR(
1404                                         "unexpected last match in input()" );
1405 #endif
1406                                 }
1407                         }
1408                 }
1409
1410         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1411         *yy_c_buf_p = '\0';     /* preserve yytext */
1412         yy_hold_char = *++yy_c_buf_p;
1413
1414
1415         return c;
1416         }
1417
1418
1419 #ifdef YY_USE_PROTOS
1420 void yyrestart( FILE *input_file )
1421 #else
1422 void yyrestart( input_file )
1423 FILE *input_file;
1424 #endif
1425         {
1426         if ( ! yy_current_buffer )
1427                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1428
1429         yy_init_buffer( yy_current_buffer, input_file );
1430         yy_load_buffer_state();
1431         }
1432
1433
1434 #ifdef YY_USE_PROTOS
1435 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1436 #else
1437 void yy_switch_to_buffer( new_buffer )
1438 YY_BUFFER_STATE new_buffer;
1439 #endif
1440         {
1441         if ( yy_current_buffer == new_buffer )
1442                 return;
1443
1444         if ( yy_current_buffer )
1445                 {
1446                 /* Flush out information for old buffer. */
1447                 *yy_c_buf_p = yy_hold_char;
1448                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1449                 yy_current_buffer->yy_n_chars = yy_n_chars;
1450                 }
1451
1452         yy_current_buffer = new_buffer;
1453         yy_load_buffer_state();
1454
1455         /* We don't actually know whether we did this switch during
1456          * EOF (yywrap()) processing, but the only time this flag
1457          * is looked at is after yywrap() is called, so it's safe
1458          * to go ahead and always set it.
1459          */
1460         yy_did_buffer_switch_on_eof = 1;
1461         }
1462
1463
1464 #ifdef YY_USE_PROTOS
1465 void yy_load_buffer_state( void )
1466 #else
1467 void yy_load_buffer_state()
1468 #endif
1469         {
1470         yy_n_chars = yy_current_buffer->yy_n_chars;
1471         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1472         yyin = yy_current_buffer->yy_input_file;
1473         yy_hold_char = *yy_c_buf_p;
1474         }
1475
1476
1477 #ifdef YY_USE_PROTOS
1478 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1479 #else
1480 YY_BUFFER_STATE yy_create_buffer( file, size )
1481 FILE *file;
1482 int size;
1483 #endif
1484         {
1485         YY_BUFFER_STATE b;
1486
1487         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1488         if ( ! b )
1489                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1490
1491         b->yy_buf_size = size;
1492
1493         /* yy_ch_buf has to be 2 characters longer than the size given because
1494          * we need to put in 2 end-of-buffer characters.
1495          */
1496         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1497         if ( ! b->yy_ch_buf )
1498                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1499
1500         b->yy_is_our_buffer = 1;
1501
1502         yy_init_buffer( b, file );
1503
1504         return b;
1505         }
1506
1507
1508 #ifdef YY_USE_PROTOS
1509 void yy_delete_buffer( YY_BUFFER_STATE b )
1510 #else
1511 void yy_delete_buffer( b )
1512 YY_BUFFER_STATE b;
1513 #endif
1514         {
1515         if ( ! b )
1516                 return;
1517
1518         if ( b == yy_current_buffer )
1519                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1520
1521         if ( b->yy_is_our_buffer )
1522                 yy_flex_free( (void *) b->yy_ch_buf );
1523
1524         yy_flex_free( (void *) b );
1525         }
1526
1527
1528 #ifndef YY_ALWAYS_INTERACTIVE
1529 #ifndef YY_NEVER_INTERACTIVE
1530 extern int isatty YY_PROTO(( int ));
1531 #endif
1532 #endif
1533
1534 #ifdef YY_USE_PROTOS
1535 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1536 #else
1537 void yy_init_buffer( b, file )
1538 YY_BUFFER_STATE b;
1539 FILE *file;
1540 #endif
1541
1542
1543         {
1544         yy_flush_buffer( b );
1545
1546         b->yy_input_file = file;
1547         b->yy_fill_buffer = 1;
1548
1549 #if YY_ALWAYS_INTERACTIVE
1550         b->yy_is_interactive = 1;
1551 #else
1552 #if YY_NEVER_INTERACTIVE
1553         b->yy_is_interactive = 0;
1554 #else
1555         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1556 #endif
1557 #endif
1558         }
1559
1560
1561 #ifdef YY_USE_PROTOS
1562 void yy_flush_buffer( YY_BUFFER_STATE b )
1563 #else
1564 void yy_flush_buffer( b )
1565 YY_BUFFER_STATE b;
1566 #endif
1567
1568         {
1569         b->yy_n_chars = 0;
1570
1571         /* We always need two end-of-buffer characters.  The first causes
1572          * a transition to the end-of-buffer state.  The second causes
1573          * a jam in that state.
1574          */
1575         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1576         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1577
1578         b->yy_buf_pos = &b->yy_ch_buf[0];
1579
1580         b->yy_at_bol = 1;
1581         b->yy_buffer_status = YY_BUFFER_NEW;
1582
1583         if ( b == yy_current_buffer )
1584                 yy_load_buffer_state();
1585         }
1586
1587
1588 #ifndef YY_NO_SCAN_BUFFER
1589 #ifdef YY_USE_PROTOS
1590 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1591 #else
1592 YY_BUFFER_STATE yy_scan_buffer( base, size )
1593 char *base;
1594 yy_size_t size;
1595 #endif
1596         {
1597         YY_BUFFER_STATE b;
1598
1599         if ( size < 2 ||
1600              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1601              base[size-1] != YY_END_OF_BUFFER_CHAR )
1602                 /* They forgot to leave room for the EOB's. */
1603                 return 0;
1604
1605         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1606         if ( ! b )
1607                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1608
1609         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1610         b->yy_buf_pos = b->yy_ch_buf = base;
1611         b->yy_is_our_buffer = 0;
1612         b->yy_input_file = 0;
1613         b->yy_n_chars = b->yy_buf_size;
1614         b->yy_is_interactive = 0;
1615         b->yy_at_bol = 1;
1616         b->yy_fill_buffer = 0;
1617         b->yy_buffer_status = YY_BUFFER_NEW;
1618
1619         yy_switch_to_buffer( b );
1620
1621         return b;
1622         }
1623 #endif
1624
1625
1626 #ifndef YY_NO_SCAN_STRING
1627 #ifdef YY_USE_PROTOS
1628 YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1629 #else
1630 YY_BUFFER_STATE yy_scan_string( str )
1631 yyconst char *str;
1632 #endif
1633         {
1634         int len;
1635         for ( len = 0; str[len]; ++len )
1636                 ;
1637
1638         return yy_scan_bytes( str, len );
1639         }
1640 #endif
1641
1642
1643 #ifndef YY_NO_SCAN_BYTES
1644 #ifdef YY_USE_PROTOS
1645 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1646 #else
1647 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1648 yyconst char *bytes;
1649 int len;
1650 #endif
1651         {
1652         YY_BUFFER_STATE b;
1653         char *buf;
1654         yy_size_t n;
1655         int i;
1656
1657         /* Get memory for full buffer, including space for trailing EOB's. */
1658         n = len + 2;
1659         buf = (char *) yy_flex_alloc( n );
1660         if ( ! buf )
1661                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1662
1663         for ( i = 0; i < len; ++i )
1664                 buf[i] = bytes[i];
1665
1666         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1667
1668         b = yy_scan_buffer( buf, n );
1669         if ( ! b )
1670                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1671
1672         /* It's okay to grow etc. this buffer, and we should throw it
1673          * away when we're done.
1674          */
1675         b->yy_is_our_buffer = 1;
1676
1677         return b;
1678         }
1679 #endif
1680
1681
1682 #ifndef YY_NO_PUSH_STATE
1683 #ifdef YY_USE_PROTOS
1684 static void yy_push_state( int new_state )
1685 #else
1686 static void yy_push_state( new_state )
1687 int new_state;
1688 #endif
1689         {
1690         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1691                 {
1692                 yy_size_t new_size;
1693
1694                 yy_start_stack_depth += YY_START_STACK_INCR;
1695                 new_size = yy_start_stack_depth * sizeof( int );
1696
1697                 if ( ! yy_start_stack )
1698                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1699
1700                 else
1701                         yy_start_stack = (int *) yy_flex_realloc(
1702                                         (void *) yy_start_stack, new_size );
1703
1704                 if ( ! yy_start_stack )
1705                         YY_FATAL_ERROR(
1706                         "out of memory expanding start-condition stack" );
1707                 }
1708
1709         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1710
1711         BEGIN(new_state);
1712         }
1713 #endif
1714
1715
1716 #ifndef YY_NO_POP_STATE
1717 static void yy_pop_state()
1718         {
1719         if ( --yy_start_stack_ptr < 0 )
1720                 YY_FATAL_ERROR( "start-condition stack underflow" );
1721
1722         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1723         }
1724 #endif
1725
1726
1727 #ifndef YY_NO_TOP_STATE
1728 static int yy_top_state()
1729         {
1730         return yy_start_stack[yy_start_stack_ptr - 1];
1731         }
1732 #endif
1733
1734 #ifndef YY_EXIT_FAILURE
1735 #define YY_EXIT_FAILURE 2
1736 #endif
1737
1738 #ifdef YY_USE_PROTOS
1739 static void yy_fatal_error( yyconst char msg[] )
1740 #else
1741 static void yy_fatal_error( msg )
1742 char msg[];
1743 #endif
1744         {
1745         (void) fprintf( stderr, "%s\n", msg );
1746         exit( YY_EXIT_FAILURE );
1747         }
1748
1749
1750
1751 /* Redefine yyless() so it works in section 3 code. */
1752
1753 #undef yyless
1754 #define yyless(n) \
1755         do \
1756                 { \
1757                 /* Undo effects of setting up yytext. */ \
1758                 yytext[yyleng] = yy_hold_char; \
1759                 yy_c_buf_p = yytext + n; \
1760                 yy_hold_char = *yy_c_buf_p; \
1761                 *yy_c_buf_p = '\0'; \
1762                 yyleng = n; \
1763                 } \
1764         while ( 0 )
1765
1766
1767 /* Internal utility routines. */
1768
1769 #ifndef yytext_ptr
1770 #ifdef YY_USE_PROTOS
1771 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1772 #else
1773 static void yy_flex_strncpy( s1, s2, n )
1774 char *s1;
1775 yyconst char *s2;
1776 int n;
1777 #endif
1778         {
1779         register int i;
1780         for ( i = 0; i < n; ++i )
1781                 s1[i] = s2[i];
1782         }
1783 #endif
1784
1785 #ifdef YY_NEED_STRLEN
1786 #ifdef YY_USE_PROTOS
1787 static int yy_flex_strlen( yyconst char *s )
1788 #else
1789 static int yy_flex_strlen( s )
1790 yyconst char *s;
1791 #endif
1792         {
1793         register int n;
1794         for ( n = 0; s[n]; ++n )
1795                 ;
1796
1797         return n;
1798         }
1799 #endif
1800
1801
1802 #ifdef YY_USE_PROTOS
1803 static void *yy_flex_alloc( yy_size_t size )
1804 #else
1805 static void *yy_flex_alloc( size )
1806 yy_size_t size;
1807 #endif
1808         {
1809         return (void *) malloc( size );
1810         }
1811
1812 #ifdef YY_USE_PROTOS
1813 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1814 #else
1815 static void *yy_flex_realloc( ptr, size )
1816 void *ptr;
1817 yy_size_t size;
1818 #endif
1819         {
1820         /* The cast to (char *) in the following accommodates both
1821          * implementations that use char* generic pointers, and those
1822          * that use void* generic pointers.  It works with the latter
1823          * because both ANSI C and C++ allow castless assignment from
1824          * any pointer type to void*, and deal with argument conversions
1825          * as though doing an assignment.
1826          */
1827         return (void *) realloc( (char *) ptr, size );
1828         }
1829
1830 #ifdef YY_USE_PROTOS
1831 static void yy_flex_free( void *ptr )
1832 #else
1833 static void yy_flex_free( ptr )
1834 void *ptr;
1835 #endif
1836         {
1837         free( ptr );
1838         }
1839
1840 #if YY_MAIN
1841 int main()
1842         {
1843         yylex();
1844         return 0;
1845         }
1846 #endif