0027960: Configuration - fix compilation of OSD_Directory with MinGW-w64
[occt.git] / src / StepFile / lex.step.c
CommitLineData
42cf5bc1 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
57c28b61 31#ifdef _MSC_VER
42cf5bc1 32# include <stdlib.h>
33# include <io.h>
57c28b61 34#endif /* _MSC_VER */
42cf5bc1 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
123typedef struct yy_buffer_state *YY_BUFFER_STATE;
124
125extern int yyleng;
126extern 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 */
165typedef unsigned int yy_size_t;
166
167
168struct 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
225static 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. */
235static char yy_hold_char;
236
237static int yy_n_chars; /* number of characters read into yy_ch_buf */
238
239
240int yyleng;
241
242/* Points to current character in buffer. */
243static char *yy_c_buf_p = (char *) 0;
244static int yy_init = 1; /* whether we need to initialize */
245static 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 */
250static int yy_did_buffer_switch_on_eof;
251
252void yyrestart YY_PROTO(( FILE *input_file ));
253
254void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
255void yy_load_buffer_state YY_PROTO(( void ));
256YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
257void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
258void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
259void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
260#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
261
262YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
263YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
264YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
265
266static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
267static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
268static 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
290typedef unsigned char YY_CHAR;
291FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
292typedef int yy_state_type;
293extern char *yytext;
294#define yytext_ptr yytext
295
296static yy_state_type yy_get_previous_state YY_PROTO(( void ));
297static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
298static int yy_get_next_buffer YY_PROTO(( void ));
299static 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
313static 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
333static 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
349static 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
381static 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
389static 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
406static 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
423static 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
454static 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
485static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
486static char *yy_full_match;
487static int yy_lp;
488static int yy_looking_for_trail_begin = 0;
489static int yy_full_lp;
490static 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 */ \
496yy_cp = yy_full_match; /* restore poss. backed-over text */ \
497yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \
498yy_state_ptr = yy_full_state; /* restore orig. state */ \
499yy_current_state = *yy_state_ptr; /* restore curr. state */ \
500++yy_lp; \
501goto find_rule; \
502}
503#define yymore() yymore_used_but_not_detected
504#define YY_MORE_ADJ 0
505#define YY_RESTORE_YY_MORE_OFFSET
506char *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
528long 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/*
535void steperror ( FILE *input_file );
536void steprestart ( FILE *input_file );
537*/
538void rec_restext(char *newtext, int lentext);
539void 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
576extern "C" int yywrap YY_PROTO(( void ));
577#else
578extern int yywrap YY_PROTO(( void ));
579#endif
580#endif
581
582#ifndef YY_NO_UNPUT
583static void yyunput YY_PROTO(( int c, char *buf_ptr ));
584#endif
585
586#ifndef yytext_ptr
587static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
588#endif
589
590#ifdef YY_NEED_STRLEN
591static int yy_flex_strlen YY_PROTO(( yyconst char * ));
592#endif
593
594#ifndef YY_NO_INPUT
595#ifdef __cplusplus
596static int yyinput YY_PROTO(( void ));
597#else
598static int input YY_PROTO(( void ));
599#endif
600#endif
601
602#if YY_STACK_USED
603static int yy_start_stack_ptr = 0;
604static int yy_start_stack_depth = 0;
605static int *yy_start_stack = 0;
606#ifndef YY_NO_PUSH_STATE
607static void yy_push_state YY_PROTO(( int new_state ));
608#endif
609#ifndef YY_NO_POP_STATE
610static void yy_pop_state YY_PROTO(( void ));
611#endif
612#ifndef YY_NO_TOP_STATE
613static 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
623YY_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
713YY_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;
760yy_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
776yy_find_action:
777 yy_current_state = *--yy_state_ptr;
778 yy_lp = yy_accept[yy_current_state];
779find_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
818do_action: /* This label is used only to access EOF actions. */
819
820
821 switch ( yy_act )
822 { /* beginning of action switch */
823case 1:
824YY_RULE_SETUP
825{;}
826 YY_BREAK
827case 2:
828YY_RULE_SETUP
829{;}
830 YY_BREAK
831case 3:
832YY_RULE_SETUP
833{ steplineno ++; }
834 YY_BREAK
835case 4:
836YY_RULE_SETUP
837{;} /* abv 30.06.00: for reading DOS files */
838 YY_BREAK
839case 5:
840YY_RULE_SETUP
841{;} /* fix from C21. for test load e3i file with line 15 with null symbols */
842 YY_BREAK
843case 6:
844*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
845yy_c_buf_p = yy_cp -= 1;
846YY_DO_BEFORE_ACTION; /* set up yytext again */
847YY_RULE_SETUP
848{ resultat(); if (modcom == 0) return(ENTITY); }
849 YY_BREAK
850case 7:
851YY_RULE_SETUP
852{ resultat(); if (modcom == 0) return(ENTITY); }
853 YY_BREAK
854case 8:
855YY_RULE_SETUP
856{ resultat(); if (modcom == 0) return(IDENT); }
857 YY_BREAK
858case 9:
859YY_RULE_SETUP
860{ resultat(); if (modcom == 0) { rec_typarg(rec_argInteger); return(QUID); } }
861 YY_BREAK
862case 10:
863YY_RULE_SETUP
864{ resultat(); if (modcom == 0) { rec_typarg(rec_argFloat); return(QUID); } }
865 YY_BREAK
866case 11:
867YY_RULE_SETUP
868{ resultat(); if (modcom == 0) { rec_typarg(rec_argFloat); return(QUID); } }
869 YY_BREAK
870case 12:
871YY_RULE_SETUP
872{ resultat(); if (modcom == 0) { rec_typarg(rec_argText); return(QUID); } }
873 YY_BREAK
874case 13:
875YY_RULE_SETUP
876{ resultat(); if (modcom == 0) { rec_typarg(rec_argHexa); return(QUID); } }
877 YY_BREAK
878case 14:
879YY_RULE_SETUP
880{ resultat(); if (modcom == 0) { rec_typarg(rec_argEnum); return(QUID); } }
881 YY_BREAK
882case 15:
883YY_RULE_SETUP
884{ if (modcom == 0) return ('('); }
885 YY_BREAK
886case 16:
887YY_RULE_SETUP
888{ if (modcom == 0) return (')'); }
889 YY_BREAK
890case 17:
891YY_RULE_SETUP
892{ if (modcom == 0) return (','); }
893 YY_BREAK
894case 18:
895YY_RULE_SETUP
896{ resultat(); if (modcom == 0) { rec_typarg(rec_argNondef); return(QUID); } }
897 YY_BREAK
898case 19:
899YY_RULE_SETUP
900{ if (modcom == 0) return ('='); }
901 YY_BREAK
902case 20:
903YY_RULE_SETUP
904{ if (modcom == 0) return (';'); }
905 YY_BREAK
906case 21:
907YY_RULE_SETUP
908{ modcom = 1; }
909 YY_BREAK
910case 22:
911YY_RULE_SETUP
912{ if (modend == 0) modcom = 0; }
913 YY_BREAK
914case 23:
915YY_RULE_SETUP
916{ if (modcom == 0) return(STEP); }
917 YY_BREAK
918case 24:
919YY_RULE_SETUP
920{ if (modcom == 0) return(HEADER); }
921 YY_BREAK
922case 25:
923YY_RULE_SETUP
924{ if (modcom == 0) return(ENDSEC); }
925 YY_BREAK
926case 26:
927YY_RULE_SETUP
928{ if (modcom == 0) return(DATA); }
929 YY_BREAK
930case 27:
931YY_RULE_SETUP
932{ if (modend == 0) {modcom = 0; return(ENDSTEP);} }
933 YY_BREAK
934case 28:
935YY_RULE_SETUP
936{ if (modend == 0) {modcom = 0; return(ENDSTEP);} }
937 YY_BREAK
938case 29:
939YY_RULE_SETUP
940{ modcom = 1; modend = 1; return(ENDSTEP); }
941 YY_BREAK
942case 30:
943YY_RULE_SETUP
944{ if (modend == 0) {modcom = 0; return(STEP); } }
945 YY_BREAK
946case 31:
947YY_RULE_SETUP
948{ if (modcom == 0) return ('/'); }
949 YY_BREAK
950case 32:
951YY_RULE_SETUP
952{ if (modcom == 0) return(SCOPE); }
953 YY_BREAK
954case 33:
955YY_RULE_SETUP
956{ if (modcom == 0) return(ENDSCOPE); }
957 YY_BREAK
958case 34:
959YY_RULE_SETUP
960{ resultat(); if (modcom == 0) return(TYPE); }
961 YY_BREAK
962case 35:
963YY_RULE_SETUP
964{ resultat(); if (modcom == 0) return(TYPE); }
965 YY_BREAK
966case 36:
967YY_RULE_SETUP
968{ resultat(); if (modcom == 0) { rec_typarg(rec_argMisc); return(QUID); } }
969 YY_BREAK
970case 37:
971YY_RULE_SETUP
972ECHO;
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
1115static 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
1245static 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
1278static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1279#else
1280static yy_state_type yy_try_NUL_trans( yy_current_state )
1281yy_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
1304static void yyunput( int c, register char *yy_bp )
1305#else
1306static void yyunput( c, yy_bp )
1307int c;
1308register 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
1347static int yyinput()
1348#else
1349static 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
1416void yyrestart( FILE *input_file )
1417#else
1418void yyrestart( input_file )
1419FILE *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
1431void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1432#else
1433void yy_switch_to_buffer( new_buffer )
1434YY_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
1461void yy_load_buffer_state( void )
1462#else
1463void 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
1474YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1475#else
1476YY_BUFFER_STATE yy_create_buffer( file, size )
1477FILE *file;
1478int 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
1505void yy_delete_buffer( YY_BUFFER_STATE b )
1506#else
1507void yy_delete_buffer( b )
1508YY_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
1526extern int isatty YY_PROTO(( int ));
1527#endif
1528#endif
1529
1530#ifdef YY_USE_PROTOS
1531void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1532#else
1533void yy_init_buffer( b, file )
1534YY_BUFFER_STATE b;
1535FILE *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
1558void yy_flush_buffer( YY_BUFFER_STATE b )
1559#else
1560void yy_flush_buffer( b )
1561YY_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
1586YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1587#else
1588YY_BUFFER_STATE yy_scan_buffer( base, size )
1589char *base;
1590yy_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
1624YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1625#else
1626YY_BUFFER_STATE yy_scan_string( str )
1627yyconst 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
1641YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1642#else
1643YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1644yyconst char *bytes;
1645int 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
1680static void yy_push_state( int new_state )
1681#else
1682static void yy_push_state( new_state )
1683int 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
1713static 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
1724static 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
1735static void yy_fatal_error( yyconst char msg[] )
1736#else
1737static void yy_fatal_error( msg )
1738char 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
1767static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1768#else
1769static void yy_flex_strncpy( s1, s2, n )
1770char *s1;
1771yyconst char *s2;
1772int 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
1783static int yy_flex_strlen( yyconst char *s )
1784#else
1785static int yy_flex_strlen( s )
1786yyconst 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
1799static void *yy_flex_alloc( yy_size_t size )
1800#else
1801static void *yy_flex_alloc( size )
1802yy_size_t size;
1803#endif
1804 {
1805 return (void *) malloc( size );
1806 }
1807
1808#ifdef YY_USE_PROTOS
1809static void *yy_flex_realloc( void *ptr, yy_size_t size )
1810#else
1811static void *yy_flex_realloc( ptr, size )
1812void *ptr;
1813yy_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
1827static void yy_flex_free( void *ptr )
1828#else
1829static void yy_flex_free( ptr )
1830void *ptr;
1831#endif
1832 {
1833 free( ptr );
1834 }
1835
1836#if YY_MAIN
1837int main()
1838 {
1839 yylex();
1840 return 0;
1841 }
1842#endif