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