0027960: Configuration - fix compilation of OSD_Directory with MinGW-w64
[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 #else
556 #pragma warning(disable:4131 4244 4273 4267 4127)
557 #endif
558
559 // Avoid includion of unistd.h if parser is generated on Linux (flex 2.5.35)
560 #define YY_NO_UNISTD_H
561
562 #endif
563
564 // disable GCC warnings in flex code
565 #ifdef __GNUC__
566 #pragma GCC diagnostic ignored "-Wunused-function"
567 #endif
568
569
570 /* Macros after this point can all be overridden by user definitions in
571  * section 1.
572  */
573
574 #ifndef YY_SKIP_YYWRAP
575 #ifdef __cplusplus
576 extern "C" int yywrap YY_PROTO(( void ));
577 #else
578 extern int yywrap YY_PROTO(( void ));
579 #endif
580 #endif
581
582 #ifndef YY_NO_UNPUT
583 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
584 #endif
585
586 #ifndef yytext_ptr
587 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
588 #endif
589
590 #ifdef YY_NEED_STRLEN
591 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
592 #endif
593
594 #ifndef YY_NO_INPUT
595 #ifdef __cplusplus
596 static int yyinput YY_PROTO(( void ));
597 #else
598 static int input YY_PROTO(( void ));
599 #endif
600 #endif
601
602 #if YY_STACK_USED
603 static int yy_start_stack_ptr = 0;
604 static int yy_start_stack_depth = 0;
605 static int *yy_start_stack = 0;
606 #ifndef YY_NO_PUSH_STATE
607 static void yy_push_state YY_PROTO(( int new_state ));
608 #endif
609 #ifndef YY_NO_POP_STATE
610 static void yy_pop_state YY_PROTO(( void ));
611 #endif
612 #ifndef YY_NO_TOP_STATE
613 static int yy_top_state YY_PROTO(( void ));
614 #endif
615
616 #else
617 #define YY_NO_PUSH_STATE 1
618 #define YY_NO_POP_STATE 1
619 #define YY_NO_TOP_STATE 1
620 #endif
621
622 #ifdef YY_MALLOC_DECL
623 YY_MALLOC_DECL
624 #else
625 #if __STDC__
626 #ifndef __cplusplus
627 #include <stdlib.h>
628 #endif
629 #else
630 /* Just try to get by without declaring the routines.  This will fail
631  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
632  * or sizeof(void*) != sizeof(int).
633  */
634 #endif
635 #endif
636
637 /* Amount of stuff to slurp up with each read. */
638 #ifndef YY_READ_BUF_SIZE
639 #define YY_READ_BUF_SIZE 8192
640 #endif
641
642 /* Copy whatever the last rule matched to the standard output. */
643
644 #ifndef ECHO
645 /* This used to be an fputs(), but since the string might contain NUL's,
646  * we now use fwrite().
647  */
648 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
649 #endif
650
651 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
652  * is returned in "result".
653  */
654 #ifndef YY_INPUT
655 #define YY_INPUT(buf,result,max_size) \
656         if ( yy_current_buffer->yy_is_interactive ) \
657                 { \
658                 int c = '*', n; \
659                 for ( n = 0; n < max_size && \
660                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
661                         buf[n] = (char) c; \
662                 if ( c == '\n' ) \
663                         buf[n++] = (char) c; \
664                 if ( c == EOF && ferror( yyin ) ) \
665                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
666                 result = n; \
667                 } \
668         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
669                   && ferror( yyin ) ) \
670                 YY_FATAL_ERROR( "input in flex scanner failed" );
671 #endif
672
673 /* No semi-colon after return; correct usage is to write "yyterminate();" -
674  * we don't want an extra ';' after the "return" because that will cause
675  * some compilers to complain about unreachable statements.
676  */
677 #ifndef yyterminate
678 #define yyterminate() return YY_NULL
679 #endif
680
681 /* Number of entries by which start-condition stack grows. */
682 #ifndef YY_START_STACK_INCR
683 #define YY_START_STACK_INCR 25
684 #endif
685
686 /* Report a fatal error. */
687 #ifndef YY_FATAL_ERROR
688 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
689 #endif
690
691 /* Default declaration of generated scanner - a define so the user can
692  * easily add parameters.
693  */
694 #ifndef YY_DECL
695 #define YY_DECL int yylex YY_PROTO(( void ))
696 #endif
697
698 /* Code executed at the beginning of each rule, after yytext and yyleng
699  * have been set up.
700  */
701 #ifndef YY_USER_ACTION
702 #define YY_USER_ACTION
703 #endif
704
705 /* Code executed at the end of each rule. */
706 #ifndef YY_BREAK
707 #define YY_BREAK break;
708 #endif
709
710 #define YY_RULE_SETUP \
711         YY_USER_ACTION
712
713 YY_DECL
714         {
715         register yy_state_type yy_current_state;
716         register char *yy_cp, *yy_bp;
717         register int yy_act;
718
719
720
721         if ( yy_init )
722                 {
723                 yy_init = 0;
724
725 #ifdef YY_USER_INIT
726                 YY_USER_INIT;
727 #endif
728
729                 if ( ! yy_start )
730                         yy_start = 1;   /* first start state */
731
732                 if ( ! yyin )
733                         yyin = stdin;
734
735                 if ( ! yyout )
736                         yyout = stdout;
737
738                 if ( ! yy_current_buffer )
739                         yy_current_buffer =
740                                 yy_create_buffer( yyin, YY_BUF_SIZE );
741
742                 yy_load_buffer_state();
743                 }
744
745         while ( 1 )             /* loops until end-of-file is reached */
746                 {
747                 yy_cp = yy_c_buf_p;
748
749                 /* Support of yytext. */
750                 *yy_cp = yy_hold_char;
751
752                 /* yy_bp points to the position in yy_ch_buf of the start of
753                  * the current run.
754                  */
755                 yy_bp = yy_cp;
756
757                 yy_current_state = yy_start;
758                 yy_state_ptr = yy_state_buf;
759                 *yy_state_ptr++ = yy_current_state;
760 yy_match:
761                 do
762                         {
763                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
764                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
765                                 {
766                                 yy_current_state = (int) yy_def[yy_current_state];
767                                 if ( yy_current_state >= 108 )
768                                         yy_c = yy_meta[(unsigned int) yy_c];
769                                 }
770                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
771                         *yy_state_ptr++ = yy_current_state;
772                         ++yy_cp;
773                         }
774                 while ( yy_base[yy_current_state] != 210 );
775
776 yy_find_action:
777                 yy_current_state = *--yy_state_ptr;
778                 yy_lp = yy_accept[yy_current_state];
779 find_rule: /* we branch to this label when backing up */
780                 for ( ; ; ) /* until we find what rule we matched */
781                         {
782                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
783                                 {
784                                 yy_act = yy_acclist[yy_lp];
785                                 if ( yy_act & YY_TRAILING_HEAD_MASK ||
786                                      yy_looking_for_trail_begin )
787                                         {
788                                         if ( yy_act == yy_looking_for_trail_begin )
789                                                 {
790                                                 yy_looking_for_trail_begin = 0;
791                                                 yy_act &= ~YY_TRAILING_HEAD_MASK;
792                                                 break;
793                                                 }
794                                         }
795                                 else if ( yy_act & YY_TRAILING_MASK )
796                                         {
797                                         yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
798                                         yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
799                                         }
800                                 else
801                                         {
802                                         yy_full_match = yy_cp;
803                                         yy_full_state = yy_state_ptr;
804                                         yy_full_lp = yy_lp;
805                                         break;
806                                         }
807                                 ++yy_lp;
808                                 goto find_rule;
809                                 }
810                         --yy_cp;
811                         yy_current_state = *--yy_state_ptr;
812                         yy_lp = yy_accept[yy_current_state];
813                         }
814
815                 YY_DO_BEFORE_ACTION;
816
817
818 do_action:      /* This label is used only to access EOF actions. */
819
820
821                 switch ( yy_act )
822         { /* beginning of action switch */
823 case 1:
824 YY_RULE_SETUP
825 {;}
826         YY_BREAK
827 case 2:
828 YY_RULE_SETUP
829 {;}
830         YY_BREAK
831 case 3:
832 YY_RULE_SETUP
833 { steplineno ++; }
834         YY_BREAK
835 case 4:
836 YY_RULE_SETUP
837 {;} /* abv 30.06.00: for reading DOS files */
838         YY_BREAK
839 case 5:
840 YY_RULE_SETUP
841 {;} /* fix from C21. for test load e3i file with line 15 with null symbols */
842         YY_BREAK
843 case 6:
844 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
845 yy_c_buf_p = yy_cp -= 1;
846 YY_DO_BEFORE_ACTION; /* set up yytext again */
847 YY_RULE_SETUP
848 { resultat();  if (modcom == 0) return(ENTITY); }
849         YY_BREAK
850 case 7:
851 YY_RULE_SETUP
852 { resultat();  if (modcom == 0) return(ENTITY); }
853         YY_BREAK
854 case 8:
855 YY_RULE_SETUP
856 { resultat();  if (modcom == 0) return(IDENT); }
857         YY_BREAK
858 case 9:
859 YY_RULE_SETUP
860 { resultat();  if (modcom == 0) { rec_typarg(rec_argInteger); return(QUID); } }
861         YY_BREAK
862 case 10:
863 YY_RULE_SETUP
864 { resultat();  if (modcom == 0) { rec_typarg(rec_argFloat); return(QUID); } }
865         YY_BREAK
866 case 11:
867 YY_RULE_SETUP
868 { resultat(); if (modcom == 0) { rec_typarg(rec_argFloat); return(QUID); } }
869         YY_BREAK
870 case 12:
871 YY_RULE_SETUP
872 { resultat(); if (modcom == 0) { rec_typarg(rec_argText); return(QUID); } }
873         YY_BREAK
874 case 13:
875 YY_RULE_SETUP
876 { resultat();  if (modcom == 0) { rec_typarg(rec_argHexa); return(QUID); } }
877         YY_BREAK
878 case 14:
879 YY_RULE_SETUP
880 { resultat();  if (modcom == 0) { rec_typarg(rec_argEnum); return(QUID); } }
881         YY_BREAK
882 case 15:
883 YY_RULE_SETUP
884 { if (modcom == 0) return ('('); }
885         YY_BREAK
886 case 16:
887 YY_RULE_SETUP
888 { if (modcom == 0) return (')'); }
889         YY_BREAK
890 case 17:
891 YY_RULE_SETUP
892 { if (modcom == 0) return (','); }
893         YY_BREAK
894 case 18:
895 YY_RULE_SETUP
896 { resultat();  if (modcom == 0) { rec_typarg(rec_argNondef); return(QUID); } }
897         YY_BREAK
898 case 19:
899 YY_RULE_SETUP
900 { if (modcom == 0) return ('='); }
901         YY_BREAK
902 case 20:
903 YY_RULE_SETUP
904 { if (modcom == 0) return (';'); }
905         YY_BREAK
906 case 21:
907 YY_RULE_SETUP
908 { modcom = 1;  }
909         YY_BREAK
910 case 22:
911 YY_RULE_SETUP
912 { if (modend == 0) modcom = 0;  }
913         YY_BREAK
914 case 23:
915 YY_RULE_SETUP
916 { if (modcom == 0) return(STEP); }
917         YY_BREAK
918 case 24:
919 YY_RULE_SETUP
920 { if (modcom == 0) return(HEADER); }
921         YY_BREAK
922 case 25:
923 YY_RULE_SETUP
924 { if (modcom == 0) return(ENDSEC); }
925         YY_BREAK
926 case 26:
927 YY_RULE_SETUP
928 { if (modcom == 0) return(DATA); }
929         YY_BREAK
930 case 27:
931 YY_RULE_SETUP
932 { if (modend == 0) {modcom = 0;  return(ENDSTEP);} }
933         YY_BREAK
934 case 28:
935 YY_RULE_SETUP
936 { if (modend == 0) {modcom = 0;  return(ENDSTEP);} }
937         YY_BREAK
938 case 29:
939 YY_RULE_SETUP
940 { modcom = 1; modend = 1; return(ENDSTEP); }
941         YY_BREAK
942 case 30:
943 YY_RULE_SETUP
944 { if (modend == 0) {modcom = 0;  return(STEP); } }
945         YY_BREAK
946 case 31:
947 YY_RULE_SETUP
948 { if (modcom == 0) return ('/'); }
949         YY_BREAK
950 case 32:
951 YY_RULE_SETUP
952 { if (modcom == 0) return(SCOPE); }
953         YY_BREAK
954 case 33:
955 YY_RULE_SETUP
956 { if (modcom == 0) return(ENDSCOPE); }
957         YY_BREAK
958 case 34:
959 YY_RULE_SETUP
960 { resultat();  if (modcom == 0) return(TYPE); }
961         YY_BREAK
962 case 35:
963 YY_RULE_SETUP
964 { resultat();  if (modcom == 0) return(TYPE); }
965         YY_BREAK
966 case 36:
967 YY_RULE_SETUP
968 { resultat();  if (modcom == 0) { rec_typarg(rec_argMisc); return(QUID); } }
969         YY_BREAK
970 case 37:
971 YY_RULE_SETUP
972 ECHO;
973         YY_BREAK
974                         case YY_STATE_EOF(INITIAL):
975                                 yyterminate();
976
977         case YY_END_OF_BUFFER:
978                 {
979                 /* Amount of text matched not including the EOB char. */
980                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
981
982                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
983                 *yy_cp = yy_hold_char;
984                 YY_RESTORE_YY_MORE_OFFSET
985
986                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
987                         {
988                         /* We're scanning a new file or input source.  It's
989                          * possible that this happened because the user
990                          * just pointed yyin at a new source and called
991                          * yylex().  If so, then we have to assure
992                          * consistency between yy_current_buffer and our
993                          * globals.  Here is the right place to do so, because
994                          * this is the first action (other than possibly a
995                          * back-up) that will match for the new input source.
996                          */
997                         yy_n_chars = yy_current_buffer->yy_n_chars;
998                         yy_current_buffer->yy_input_file = yyin;
999                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1000                         }
1001
1002                 /* Note that here we test for yy_c_buf_p "<=" to the position
1003                  * of the first EOB in the buffer, since yy_c_buf_p will
1004                  * already have been incremented past the NUL character
1005                  * (since all states make transitions on EOB to the
1006                  * end-of-buffer state).  Contrast this with the test
1007                  * in input().
1008                  */
1009                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1010                         { /* This was really a NUL. */
1011                         yy_state_type yy_next_state;
1012
1013                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1014
1015                         yy_current_state = yy_get_previous_state();
1016
1017                         /* Okay, we're now positioned to make the NUL
1018                          * transition.  We couldn't have
1019                          * yy_get_previous_state() go ahead and do it
1020                          * for us because it doesn't know how to deal
1021                          * with the possibility of jamming (and we don't
1022                          * want to build jamming into it because then it
1023                          * will run more slowly).
1024                          */
1025
1026                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1027
1028                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1029
1030                         if ( yy_next_state )
1031                                 {
1032                                 /* Consume the NUL. */
1033                                 yy_cp = ++yy_c_buf_p;
1034                                 yy_current_state = yy_next_state;
1035                                 goto yy_match;
1036                                 }
1037
1038                         else
1039                                 {
1040                                 yy_cp = yy_c_buf_p;
1041                                 goto yy_find_action;
1042                                 }
1043                         }
1044
1045                 else switch ( yy_get_next_buffer() )
1046                         {
1047                         case EOB_ACT_END_OF_FILE:
1048                                 {
1049                                 yy_did_buffer_switch_on_eof = 0;
1050
1051                                 if ( yywrap() )
1052                                         {
1053                                         /* Note: because we've taken care in
1054                                          * yy_get_next_buffer() to have set up
1055                                          * yytext, we can now set up
1056                                          * yy_c_buf_p so that if some total
1057                                          * hoser (like flex itself) wants to
1058                                          * call the scanner after we return the
1059                                          * YY_NULL, it'll still work - another
1060                                          * YY_NULL will get returned.
1061                                          */
1062                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1063
1064                                         yy_act = YY_STATE_EOF(YY_START);
1065                                         goto do_action;
1066                                         }
1067
1068                                 else
1069                                         {
1070                                         if ( ! yy_did_buffer_switch_on_eof )
1071                                                 YY_NEW_FILE;
1072                                         }
1073                                 break;
1074                                 }
1075
1076                         case EOB_ACT_CONTINUE_SCAN:
1077                                 yy_c_buf_p =
1078                                         yytext_ptr + yy_amount_of_matched_text;
1079
1080                                 yy_current_state = yy_get_previous_state();
1081
1082                                 yy_cp = yy_c_buf_p;
1083                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1084                                 goto yy_match;
1085
1086                         case EOB_ACT_LAST_MATCH:
1087                                 yy_c_buf_p =
1088                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1089
1090                                 yy_current_state = yy_get_previous_state();
1091
1092                                 yy_cp = yy_c_buf_p;
1093                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1094                                 goto yy_find_action;
1095                         }
1096                 break;
1097                 }
1098
1099         default:
1100                 YY_FATAL_ERROR(
1101                         "fatal flex scanner internal error--no action found" );
1102         } /* end of action switch */
1103                 } /* end of scanning one token */
1104         } /* end of yylex */
1105
1106
1107 /* yy_get_next_buffer - try to read in a new buffer
1108  *
1109  * Returns a code representing an action:
1110  *      EOB_ACT_LAST_MATCH -
1111  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1112  *      EOB_ACT_END_OF_FILE - end of file
1113  */
1114
1115 static int yy_get_next_buffer()
1116         {
1117         register char *dest = yy_current_buffer->yy_ch_buf;
1118         register char *source = yytext_ptr;
1119         register int number_to_move, i;
1120         int ret_val;
1121
1122         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1123                 YY_FATAL_ERROR(
1124                 "fatal flex scanner internal error--end of buffer missed" );
1125
1126         if ( yy_current_buffer->yy_fill_buffer == 0 )
1127                 { /* Don't try to fill the buffer, so this is an EOF. */
1128                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1129                         {
1130                         /* We matched a single character, the EOB, so
1131                          * treat this as a final EOF.
1132                          */
1133                         return EOB_ACT_END_OF_FILE;
1134                         }
1135
1136                 else
1137                         {
1138                         /* We matched some text prior to the EOB, first
1139                          * process it.
1140                          */
1141                         return EOB_ACT_LAST_MATCH;
1142                         }
1143                 }
1144
1145         /* Try to read more data. */
1146
1147         /* First move last chars to start of buffer. */
1148         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1149
1150         for ( i = 0; i < number_to_move; ++i )
1151                 *(dest++) = *(source++);
1152
1153         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1154                 /* don't do the read, it's not guaranteed to return an EOF,
1155                  * just force an EOF
1156                  */
1157                 yy_n_chars = 0;
1158
1159         else
1160                 {
1161                 int num_to_read =
1162                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1163
1164                 while ( num_to_read <= 0 )
1165                         { /* Not enough room in the buffer - grow it. */
1166 #ifdef YY_USES_REJECT
1167                         YY_FATAL_ERROR(
1168 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1169 #else
1170
1171                         /* just a shorter name for the current buffer */
1172                         YY_BUFFER_STATE b = yy_current_buffer;
1173
1174                         int yy_c_buf_p_offset =
1175                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1176
1177                         if ( b->yy_is_our_buffer )
1178                                 {
1179                                 int new_size = b->yy_buf_size * 2;
1180
1181                                 if ( new_size <= 0 )
1182                                         b->yy_buf_size += b->yy_buf_size / 8;
1183                                 else
1184                                         b->yy_buf_size *= 2;
1185
1186                                 b->yy_ch_buf = (char *)
1187                                         /* Include room in for 2 EOB chars. */
1188                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1189                                                          b->yy_buf_size + 2 );
1190                                 }
1191                         else
1192                                 /* Can't grow it, we don't own it. */
1193                                 b->yy_ch_buf = 0;
1194
1195                         if ( ! b->yy_ch_buf )
1196                                 YY_FATAL_ERROR(
1197                                 "fatal error - scanner input buffer overflow" );
1198
1199                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1200
1201                         num_to_read = yy_current_buffer->yy_buf_size -
1202                                                 number_to_move - 1;
1203 #endif
1204                         }
1205
1206                 if ( num_to_read > YY_READ_BUF_SIZE )
1207                         num_to_read = YY_READ_BUF_SIZE;
1208
1209                 /* Read in more data. */
1210                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1211                         yy_n_chars, num_to_read );
1212                 }
1213
1214         if ( yy_n_chars == 0 )
1215                 {
1216                 if ( number_to_move == YY_MORE_ADJ )
1217                         {
1218                         ret_val = EOB_ACT_END_OF_FILE;
1219                         yyrestart( yyin );
1220                         }
1221
1222                 else
1223                         {
1224                         ret_val = EOB_ACT_LAST_MATCH;
1225                         yy_current_buffer->yy_buffer_status =
1226                                 YY_BUFFER_EOF_PENDING;
1227                         }
1228                 }
1229
1230         else
1231                 ret_val = EOB_ACT_CONTINUE_SCAN;
1232
1233         yy_n_chars += number_to_move;
1234         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1235         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1236
1237         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1238
1239         return ret_val;
1240         }
1241
1242
1243 /* yy_get_previous_state - get the state just before the EOB char was reached */
1244
1245 static yy_state_type yy_get_previous_state()
1246         {
1247         register yy_state_type yy_current_state;
1248         register char *yy_cp;
1249
1250         yy_current_state = yy_start;
1251         yy_state_ptr = yy_state_buf;
1252         *yy_state_ptr++ = yy_current_state;
1253
1254         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1255                 {
1256                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 39);
1257                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1258                         {
1259                         yy_current_state = (int) yy_def[yy_current_state];
1260                         if ( yy_current_state >= 108 )
1261                                 yy_c = yy_meta[(unsigned int) yy_c];
1262                         }
1263                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1264                 *yy_state_ptr++ = yy_current_state;
1265                 }
1266
1267         return yy_current_state;
1268         }
1269
1270
1271 /* yy_try_NUL_trans - try to make a transition on the NUL character
1272  *
1273  * synopsis
1274  *      next_state = yy_try_NUL_trans( current_state );
1275  */
1276
1277 #ifdef YY_USE_PROTOS
1278 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1279 #else
1280 static yy_state_type yy_try_NUL_trans( yy_current_state )
1281 yy_state_type yy_current_state;
1282 #endif
1283         {
1284         register int yy_is_jam;
1285
1286         register YY_CHAR yy_c = 39;
1287         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1288                 {
1289                 yy_current_state = (int) yy_def[yy_current_state];
1290                 if ( yy_current_state >= 108 )
1291                         yy_c = yy_meta[(unsigned int) yy_c];
1292                 }
1293         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1294         yy_is_jam = (yy_current_state == 107);
1295         if ( ! yy_is_jam )
1296                 *yy_state_ptr++ = yy_current_state;
1297
1298         return yy_is_jam ? 0 : yy_current_state;
1299         }
1300
1301
1302 #ifndef YY_NO_UNPUT
1303 #ifdef YY_USE_PROTOS
1304 static void yyunput( int c, register char *yy_bp )
1305 #else
1306 static void yyunput( c, yy_bp )
1307 int c;
1308 register char *yy_bp;
1309 #endif
1310         {
1311         register char *yy_cp = yy_c_buf_p;
1312
1313         /* undo effects of setting up yytext */
1314         *yy_cp = yy_hold_char;
1315
1316         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1317                 { /* need to shift things up to make room */
1318                 /* +2 for EOB chars. */
1319                 register int number_to_move = yy_n_chars + 2;
1320                 register char *dest = &yy_current_buffer->yy_ch_buf[
1321                                         yy_current_buffer->yy_buf_size + 2];
1322                 register char *source =
1323                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1324
1325                 while ( source > yy_current_buffer->yy_ch_buf )
1326                         *--dest = *--source;
1327
1328                 yy_cp += (int) (dest - source);
1329                 yy_bp += (int) (dest - source);
1330                 yy_n_chars = yy_current_buffer->yy_buf_size;
1331
1332                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1333                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1334                 }
1335
1336         *--yy_cp = (char) c;
1337
1338
1339         yytext_ptr = yy_bp;
1340         yy_hold_char = *yy_cp;
1341         yy_c_buf_p = yy_cp;
1342         }
1343 #endif  /* ifndef YY_NO_UNPUT */
1344
1345
1346 #ifdef __cplusplus
1347 static int yyinput()
1348 #else
1349 static int input()
1350 #endif
1351         {
1352         int c;
1353
1354         *yy_c_buf_p = yy_hold_char;
1355
1356         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1357                 {
1358                 /* yy_c_buf_p now points to the character we want to return.
1359                  * If this occurs *before* the EOB characters, then it's a
1360                  * valid NUL; if not, then we've hit the end of the buffer.
1361                  */
1362                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1363                         /* This was really a NUL. */
1364                         *yy_c_buf_p = '\0';
1365
1366                 else
1367                         { /* need more input */
1368                         int offset = yy_c_buf_p - yytext_ptr;
1369                         ++yy_c_buf_p;
1370
1371                         switch ( yy_get_next_buffer() )
1372                                 {
1373                                 case EOB_ACT_END_OF_FILE:
1374                                         {
1375                                         if ( yywrap() )
1376                                                 {
1377                                                 yy_c_buf_p = yytext_ptr + offset;
1378                                                 return EOF;
1379                                                 }
1380
1381                                         if ( ! yy_did_buffer_switch_on_eof )
1382                                                 YY_NEW_FILE;
1383 #ifdef __cplusplus
1384                                         return yyinput();
1385 #else
1386                                         return input();
1387 #endif
1388                                         }
1389
1390                                 case EOB_ACT_CONTINUE_SCAN:
1391                                         yy_c_buf_p = yytext_ptr + offset;
1392                                         break;
1393
1394                                 case EOB_ACT_LAST_MATCH:
1395 #ifdef __cplusplus
1396                                         YY_FATAL_ERROR(
1397                                         "unexpected last match in yyinput()" );
1398 #else
1399                                         YY_FATAL_ERROR(
1400                                         "unexpected last match in input()" );
1401 #endif
1402                                 }
1403                         }
1404                 }
1405
1406         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1407         *yy_c_buf_p = '\0';     /* preserve yytext */
1408         yy_hold_char = *++yy_c_buf_p;
1409
1410
1411         return c;
1412         }
1413
1414
1415 #ifdef YY_USE_PROTOS
1416 void yyrestart( FILE *input_file )
1417 #else
1418 void yyrestart( input_file )
1419 FILE *input_file;
1420 #endif
1421         {
1422         if ( ! yy_current_buffer )
1423                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1424
1425         yy_init_buffer( yy_current_buffer, input_file );
1426         yy_load_buffer_state();
1427         }
1428
1429
1430 #ifdef YY_USE_PROTOS
1431 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1432 #else
1433 void yy_switch_to_buffer( new_buffer )
1434 YY_BUFFER_STATE new_buffer;
1435 #endif
1436         {
1437         if ( yy_current_buffer == new_buffer )
1438                 return;
1439
1440         if ( yy_current_buffer )
1441                 {
1442                 /* Flush out information for old buffer. */
1443                 *yy_c_buf_p = yy_hold_char;
1444                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1445                 yy_current_buffer->yy_n_chars = yy_n_chars;
1446                 }
1447
1448         yy_current_buffer = new_buffer;
1449         yy_load_buffer_state();
1450
1451         /* We don't actually know whether we did this switch during
1452          * EOF (yywrap()) processing, but the only time this flag
1453          * is looked at is after yywrap() is called, so it's safe
1454          * to go ahead and always set it.
1455          */
1456         yy_did_buffer_switch_on_eof = 1;
1457         }
1458
1459
1460 #ifdef YY_USE_PROTOS
1461 void yy_load_buffer_state( void )
1462 #else
1463 void yy_load_buffer_state()
1464 #endif
1465         {
1466         yy_n_chars = yy_current_buffer->yy_n_chars;
1467         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1468         yyin = yy_current_buffer->yy_input_file;
1469         yy_hold_char = *yy_c_buf_p;
1470         }
1471
1472
1473 #ifdef YY_USE_PROTOS
1474 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1475 #else
1476 YY_BUFFER_STATE yy_create_buffer( file, size )
1477 FILE *file;
1478 int size;
1479 #endif
1480         {
1481         YY_BUFFER_STATE b;
1482
1483         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1484         if ( ! b )
1485                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1486
1487         b->yy_buf_size = size;
1488
1489         /* yy_ch_buf has to be 2 characters longer than the size given because
1490          * we need to put in 2 end-of-buffer characters.
1491          */
1492         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1493         if ( ! b->yy_ch_buf )
1494                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1495
1496         b->yy_is_our_buffer = 1;
1497
1498         yy_init_buffer( b, file );
1499
1500         return b;
1501         }
1502
1503
1504 #ifdef YY_USE_PROTOS
1505 void yy_delete_buffer( YY_BUFFER_STATE b )
1506 #else
1507 void yy_delete_buffer( b )
1508 YY_BUFFER_STATE b;
1509 #endif
1510         {
1511         if ( ! b )
1512                 return;
1513
1514         if ( b == yy_current_buffer )
1515                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1516
1517         if ( b->yy_is_our_buffer )
1518                 yy_flex_free( (void *) b->yy_ch_buf );
1519
1520         yy_flex_free( (void *) b );
1521         }
1522
1523
1524 #ifndef YY_ALWAYS_INTERACTIVE
1525 #ifndef YY_NEVER_INTERACTIVE
1526 extern int isatty YY_PROTO(( int ));
1527 #endif
1528 #endif
1529
1530 #ifdef YY_USE_PROTOS
1531 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1532 #else
1533 void yy_init_buffer( b, file )
1534 YY_BUFFER_STATE b;
1535 FILE *file;
1536 #endif
1537
1538
1539         {
1540         yy_flush_buffer( b );
1541
1542         b->yy_input_file = file;
1543         b->yy_fill_buffer = 1;
1544
1545 #if YY_ALWAYS_INTERACTIVE
1546         b->yy_is_interactive = 1;
1547 #else
1548 #if YY_NEVER_INTERACTIVE
1549         b->yy_is_interactive = 0;
1550 #else
1551         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1552 #endif
1553 #endif
1554         }
1555
1556
1557 #ifdef YY_USE_PROTOS
1558 void yy_flush_buffer( YY_BUFFER_STATE b )
1559 #else
1560 void yy_flush_buffer( b )
1561 YY_BUFFER_STATE b;
1562 #endif
1563
1564         {
1565         b->yy_n_chars = 0;
1566
1567         /* We always need two end-of-buffer characters.  The first causes
1568          * a transition to the end-of-buffer state.  The second causes
1569          * a jam in that state.
1570          */
1571         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1572         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1573
1574         b->yy_buf_pos = &b->yy_ch_buf[0];
1575
1576         b->yy_at_bol = 1;
1577         b->yy_buffer_status = YY_BUFFER_NEW;
1578
1579         if ( b == yy_current_buffer )
1580                 yy_load_buffer_state();
1581         }
1582
1583
1584 #ifndef YY_NO_SCAN_BUFFER
1585 #ifdef YY_USE_PROTOS
1586 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1587 #else
1588 YY_BUFFER_STATE yy_scan_buffer( base, size )
1589 char *base;
1590 yy_size_t size;
1591 #endif
1592         {
1593         YY_BUFFER_STATE b;
1594
1595         if ( size < 2 ||
1596              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1597              base[size-1] != YY_END_OF_BUFFER_CHAR )
1598                 /* They forgot to leave room for the EOB's. */
1599                 return 0;
1600
1601         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1602         if ( ! b )
1603                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1604
1605         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1606         b->yy_buf_pos = b->yy_ch_buf = base;
1607         b->yy_is_our_buffer = 0;
1608         b->yy_input_file = 0;
1609         b->yy_n_chars = b->yy_buf_size;
1610         b->yy_is_interactive = 0;
1611         b->yy_at_bol = 1;
1612         b->yy_fill_buffer = 0;
1613         b->yy_buffer_status = YY_BUFFER_NEW;
1614
1615         yy_switch_to_buffer( b );
1616
1617         return b;
1618         }
1619 #endif
1620
1621
1622 #ifndef YY_NO_SCAN_STRING
1623 #ifdef YY_USE_PROTOS
1624 YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1625 #else
1626 YY_BUFFER_STATE yy_scan_string( str )
1627 yyconst char *str;
1628 #endif
1629         {
1630         int len;
1631         for ( len = 0; str[len]; ++len )
1632                 ;
1633
1634         return yy_scan_bytes( str, len );
1635         }
1636 #endif
1637
1638
1639 #ifndef YY_NO_SCAN_BYTES
1640 #ifdef YY_USE_PROTOS
1641 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1642 #else
1643 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1644 yyconst char *bytes;
1645 int len;
1646 #endif
1647         {
1648         YY_BUFFER_STATE b;
1649         char *buf;
1650         yy_size_t n;
1651         int i;
1652
1653         /* Get memory for full buffer, including space for trailing EOB's. */
1654         n = len + 2;
1655         buf = (char *) yy_flex_alloc( n );
1656         if ( ! buf )
1657                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1658
1659         for ( i = 0; i < len; ++i )
1660                 buf[i] = bytes[i];
1661
1662         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1663
1664         b = yy_scan_buffer( buf, n );
1665         if ( ! b )
1666                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1667
1668         /* It's okay to grow etc. this buffer, and we should throw it
1669          * away when we're done.
1670          */
1671         b->yy_is_our_buffer = 1;
1672
1673         return b;
1674         }
1675 #endif
1676
1677
1678 #ifndef YY_NO_PUSH_STATE
1679 #ifdef YY_USE_PROTOS
1680 static void yy_push_state( int new_state )
1681 #else
1682 static void yy_push_state( new_state )
1683 int new_state;
1684 #endif
1685         {
1686         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1687                 {
1688                 yy_size_t new_size;
1689
1690                 yy_start_stack_depth += YY_START_STACK_INCR;
1691                 new_size = yy_start_stack_depth * sizeof( int );
1692
1693                 if ( ! yy_start_stack )
1694                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1695
1696                 else
1697                         yy_start_stack = (int *) yy_flex_realloc(
1698                                         (void *) yy_start_stack, new_size );
1699
1700                 if ( ! yy_start_stack )
1701                         YY_FATAL_ERROR(
1702                         "out of memory expanding start-condition stack" );
1703                 }
1704
1705         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1706
1707         BEGIN(new_state);
1708         }
1709 #endif
1710
1711
1712 #ifndef YY_NO_POP_STATE
1713 static void yy_pop_state()
1714         {
1715         if ( --yy_start_stack_ptr < 0 )
1716                 YY_FATAL_ERROR( "start-condition stack underflow" );
1717
1718         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1719         }
1720 #endif
1721
1722
1723 #ifndef YY_NO_TOP_STATE
1724 static int yy_top_state()
1725         {
1726         return yy_start_stack[yy_start_stack_ptr - 1];
1727         }
1728 #endif
1729
1730 #ifndef YY_EXIT_FAILURE
1731 #define YY_EXIT_FAILURE 2
1732 #endif
1733
1734 #ifdef YY_USE_PROTOS
1735 static void yy_fatal_error( yyconst char msg[] )
1736 #else
1737 static void yy_fatal_error( msg )
1738 char msg[];
1739 #endif
1740         {
1741         (void) fprintf( stderr, "%s\n", msg );
1742         exit( YY_EXIT_FAILURE );
1743         }
1744
1745
1746
1747 /* Redefine yyless() so it works in section 3 code. */
1748
1749 #undef yyless
1750 #define yyless(n) \
1751         do \
1752                 { \
1753                 /* Undo effects of setting up yytext. */ \
1754                 yytext[yyleng] = yy_hold_char; \
1755                 yy_c_buf_p = yytext + n; \
1756                 yy_hold_char = *yy_c_buf_p; \
1757                 *yy_c_buf_p = '\0'; \
1758                 yyleng = n; \
1759                 } \
1760         while ( 0 )
1761
1762
1763 /* Internal utility routines. */
1764
1765 #ifndef yytext_ptr
1766 #ifdef YY_USE_PROTOS
1767 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1768 #else
1769 static void yy_flex_strncpy( s1, s2, n )
1770 char *s1;
1771 yyconst char *s2;
1772 int n;
1773 #endif
1774         {
1775         register int i;
1776         for ( i = 0; i < n; ++i )
1777                 s1[i] = s2[i];
1778         }
1779 #endif
1780
1781 #ifdef YY_NEED_STRLEN
1782 #ifdef YY_USE_PROTOS
1783 static int yy_flex_strlen( yyconst char *s )
1784 #else
1785 static int yy_flex_strlen( s )
1786 yyconst char *s;
1787 #endif
1788         {
1789         register int n;
1790         for ( n = 0; s[n]; ++n )
1791                 ;
1792
1793         return n;
1794         }
1795 #endif
1796
1797
1798 #ifdef YY_USE_PROTOS
1799 static void *yy_flex_alloc( yy_size_t size )
1800 #else
1801 static void *yy_flex_alloc( size )
1802 yy_size_t size;
1803 #endif
1804         {
1805         return (void *) malloc( size );
1806         }
1807
1808 #ifdef YY_USE_PROTOS
1809 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1810 #else
1811 static void *yy_flex_realloc( ptr, size )
1812 void *ptr;
1813 yy_size_t size;
1814 #endif
1815         {
1816         /* The cast to (char *) in the following accommodates both
1817          * implementations that use char* generic pointers, and those
1818          * that use void* generic pointers.  It works with the latter
1819          * because both ANSI C and C++ allow castless assignment from
1820          * any pointer type to void*, and deal with argument conversions
1821          * as though doing an assignment.
1822          */
1823         return (void *) realloc( (char *) ptr, size );
1824         }
1825
1826 #ifdef YY_USE_PROTOS
1827 static void yy_flex_free( void *ptr )
1828 #else
1829 static void yy_flex_free( ptr )
1830 void *ptr;
1831 #endif
1832         {
1833         free( ptr );
1834         }
1835
1836 #if YY_MAIN
1837 int main()
1838         {
1839         yylex();
1840         return 0;
1841         }
1842 #endif