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