source: trunk/orbital/generated/mesh-scanner.cpp @ 1495

Last change on this file since 1495 was 1495, checked in by sam, 9 years ago

orbital: allow 6- and 8-component hex colour values.

  • Property svn:keywords set to Id
File size: 46.5 KB
Line 
1#line 2 "generated/mesh-scanner.cpp"
2
3#line 4 "generated/mesh-scanner.cpp"
4
5#define  YY_INT_ALIGNED short int
6
7/* A lexical scanner generated by flex */
8
9#define FLEX_SCANNER
10#define YY_FLEX_MAJOR_VERSION 2
11#define YY_FLEX_MINOR_VERSION 5
12#define YY_FLEX_SUBMINOR_VERSION 35
13#if YY_FLEX_SUBMINOR_VERSION > 0
14#define FLEX_BETA
15#endif
16
17    /* The c++ scanner is a mess. The FlexLexer.h header file relies on the
18     * following macro. This is required in order to pass the c++-multiple-scanners
19     * test in the regression suite. We get reports that it breaks inheritance.
20     * We will address this in a future release of flex, or omit the C++ scanner
21     * altogether.
22     */
23    #define yyFlexLexer MeshFlexLexer
24
25/* First, we deal with  platform-specific or compiler-specific issues. */
26
27/* begin standard C headers. */
28
29/* end standard C headers. */
30
31/* flex integer type definitions */
32
33#ifndef FLEXINT_H
34#define FLEXINT_H
35
36/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
37
38#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
39
40/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
41 * if you want the limit (max/min) macros for int types.
42 */
43#ifndef __STDC_LIMIT_MACROS
44#define __STDC_LIMIT_MACROS 1
45#endif
46
47#include <inttypes.h>
48typedef int8_t flex_int8_t;
49typedef uint8_t flex_uint8_t;
50typedef int16_t flex_int16_t;
51typedef uint16_t flex_uint16_t;
52typedef int32_t flex_int32_t;
53typedef uint32_t flex_uint32_t;
54#else
55typedef signed char flex_int8_t;
56typedef short int flex_int16_t;
57typedef int flex_int32_t;
58typedef unsigned char flex_uint8_t;
59typedef unsigned short int flex_uint16_t;
60typedef unsigned int flex_uint32_t;
61
62/* Limits of integral types. */
63#ifndef INT8_MIN
64#define INT8_MIN               (-128)
65#endif
66#ifndef INT16_MIN
67#define INT16_MIN              (-32767-1)
68#endif
69#ifndef INT32_MIN
70#define INT32_MIN              (-2147483647-1)
71#endif
72#ifndef INT8_MAX
73#define INT8_MAX               (127)
74#endif
75#ifndef INT16_MAX
76#define INT16_MAX              (32767)
77#endif
78#ifndef INT32_MAX
79#define INT32_MAX              (2147483647)
80#endif
81#ifndef UINT8_MAX
82#define UINT8_MAX              (255U)
83#endif
84#ifndef UINT16_MAX
85#define UINT16_MAX             (65535U)
86#endif
87#ifndef UINT32_MAX
88#define UINT32_MAX             (4294967295U)
89#endif
90
91#endif /* ! C99 */
92
93#endif /* ! FLEXINT_H */
94
95/* begin standard C++ headers. */
96#include <iostream>
97#include <errno.h>
98#include <cstdlib>
99#include <cstdio>
100#include <cstring>
101/* end standard C++ headers. */
102
103#ifdef __cplusplus
104
105/* The "const" storage-class-modifier is valid. */
106#define YY_USE_CONST
107
108#else   /* ! __cplusplus */
109
110/* C99 requires __STDC__ to be defined as 1. */
111#if defined (__STDC__)
112
113#define YY_USE_CONST
114
115#endif  /* defined (__STDC__) */
116#endif  /* ! __cplusplus */
117
118#ifdef YY_USE_CONST
119#define yyconst const
120#else
121#define yyconst
122#endif
123
124/* Returned upon end-of-file. */
125#define YY_NULL 0
126
127/* Promotes a possibly negative, possibly signed char to an unsigned
128 * integer for use as an array index.  If the signed char is negative,
129 * we want to instead treat it as an 8-bit unsigned char, hence the
130 * double cast.
131 */
132#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
133
134/* Enter a start condition.  This macro really ought to take a parameter,
135 * but we do it the disgusting crufty way forced on us by the ()-less
136 * definition of BEGIN.
137 */
138#define BEGIN (yy_start) = 1 + 2 *
139
140/* Translate the current start state into a value that can be later handed
141 * to BEGIN to return to the state.  The YYSTATE alias is for lex
142 * compatibility.
143 */
144#define YY_START (((yy_start) - 1) / 2)
145#define YYSTATE YY_START
146
147/* Action number for EOF rule of a given start state. */
148#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
149
150/* Special action meaning "start processing a new file". */
151#define YY_NEW_FILE yyrestart( yyin  )
152
153#define YY_END_OF_BUFFER_CHAR 0
154
155/* Size of default input buffer. */
156#ifndef YY_BUF_SIZE
157#ifdef __ia64__
158/* On IA-64, the buffer size is 16k, not 8k.
159 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
160 * Ditto for the __ia64__ case accordingly.
161 */
162#define YY_BUF_SIZE 32768
163#else
164#define YY_BUF_SIZE 16384
165#endif /* __ia64__ */
166#endif
167
168/* The state buf must be large enough to hold one state per character in the main buffer.
169 */
170#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
171
172#ifndef YY_TYPEDEF_YY_BUFFER_STATE
173#define YY_TYPEDEF_YY_BUFFER_STATE
174typedef struct yy_buffer_state *YY_BUFFER_STATE;
175#endif
176
177extern int yyleng;
178
179#define EOB_ACT_CONTINUE_SCAN 0
180#define EOB_ACT_END_OF_FILE 1
181#define EOB_ACT_LAST_MATCH 2
182
183    #define YY_LESS_LINENO(n)
184   
185/* Return all but the first "n" matched characters back to the input stream. */
186#define yyless(n) \
187        do \
188                { \
189                /* Undo effects of setting up yytext. */ \
190        int yyless_macro_arg = (n); \
191        YY_LESS_LINENO(yyless_macro_arg);\
192                *yy_cp = (yy_hold_char); \
193                YY_RESTORE_YY_MORE_OFFSET \
194                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
196                } \
197        while ( 0 )
198
199#define unput(c) yyunput( c, (yytext_ptr)  )
200
201#ifndef YY_TYPEDEF_YY_SIZE_T
202#define YY_TYPEDEF_YY_SIZE_T
203typedef size_t yy_size_t;
204#endif
205
206#ifndef YY_STRUCT_YY_BUFFER_STATE
207#define YY_STRUCT_YY_BUFFER_STATE
208struct yy_buffer_state
209        {
210
211        std::istream* yy_input_file;
212
213        char *yy_ch_buf;                /* input buffer */
214        char *yy_buf_pos;               /* current position in input buffer */
215
216        /* Size of input buffer in bytes, not including room for EOB
217         * characters.
218         */
219        yy_size_t yy_buf_size;
220
221        /* Number of characters read into yy_ch_buf, not including EOB
222         * characters.
223         */
224        int yy_n_chars;
225
226        /* Whether we "own" the buffer - i.e., we know we created it,
227         * and can realloc() it to grow it, and should free() it to
228         * delete it.
229         */
230        int yy_is_our_buffer;
231
232        /* Whether this is an "interactive" input source; if so, and
233         * if we're using stdio for input, then we want to use getc()
234         * instead of fread(), to make sure we stop fetching input after
235         * each newline.
236         */
237        int yy_is_interactive;
238
239        /* Whether we're considered to be at the beginning of a line.
240         * If so, '^' rules will be active on the next match, otherwise
241         * not.
242         */
243        int yy_at_bol;
244
245    int yy_bs_lineno; /**< The line count. */
246    int yy_bs_column; /**< The column count. */
247   
248        /* Whether to try to fill the input buffer when we reach the
249         * end of it.
250         */
251        int yy_fill_buffer;
252
253        int yy_buffer_status;
254
255#define YY_BUFFER_NEW 0
256#define YY_BUFFER_NORMAL 1
257        /* When an EOF's been seen but there's still some text to process
258         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
259         * shouldn't try reading from the input source any more.  We might
260         * still have a bunch of tokens to match, though, because of
261         * possible backing-up.
262         *
263         * When we actually see the EOF, we change the status to "new"
264         * (via yyrestart()), so that the user can continue scanning by
265         * just pointing yyin at a new input file.
266         */
267#define YY_BUFFER_EOF_PENDING 2
268
269        };
270#endif /* !YY_STRUCT_YY_BUFFER_STATE */
271
272/* We provide macros for accessing buffer states in case in the
273 * future we want to put the buffer states in a more general
274 * "scanner state".
275 *
276 * Returns the top of the stack, or NULL.
277 */
278#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
279                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
280                          : NULL)
281
282/* Same as previous macro, but useful when we know that the buffer stack is not
283 * NULL or when we need an lvalue. For internal use only.
284 */
285#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
286
287void *Meshalloc (yy_size_t  );
288void *Meshrealloc (void *,yy_size_t  );
289void Meshfree (void *  );
290
291#define yy_new_buffer yy_create_buffer
292
293#define yy_set_interactive(is_interactive) \
294        { \
295        if ( ! YY_CURRENT_BUFFER ){ \
296        yyensure_buffer_stack (); \
297                YY_CURRENT_BUFFER_LVALUE =    \
298            yy_create_buffer( yyin, YY_BUF_SIZE ); \
299        } \
300        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
301        }
302
303#define yy_set_bol(at_bol) \
304        { \
305        if ( ! YY_CURRENT_BUFFER ){\
306        yyensure_buffer_stack (); \
307                YY_CURRENT_BUFFER_LVALUE =    \
308            yy_create_buffer( yyin, YY_BUF_SIZE ); \
309        } \
310        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
311        }
312
313#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
314
315/* Begin user sect3 */
316
317typedef unsigned char YY_CHAR;
318
319#define yytext_ptr yytext
320
321#include <FlexLexer.h>
322
323/* Done after the current pattern has been matched and before the
324 * corresponding action - sets up yytext.
325 */
326#define YY_DO_BEFORE_ACTION \
327        (yytext_ptr) = yy_bp; \
328        yyleng = (size_t) (yy_cp - yy_bp); \
329        (yy_hold_char) = *yy_cp; \
330        *yy_cp = '\0'; \
331        (yy_c_buf_p) = yy_cp;
332
333#define YY_NUM_RULES 42
334#define YY_END_OF_BUFFER 43
335/* This struct is not used in this scanner,
336   but its presence is necessary. */
337struct yy_trans_info
338        {
339        flex_int32_t yy_verify;
340        flex_int32_t yy_nxt;
341        };
342static yyconst flex_int16_t yy_accept[68] =
343    {   0,
344        0,    0,   43,   41,   40,   39,   41,   41,   36,   41,
345       35,   37,   38,   41,   41,   41,   16,    6,    0,    0,
346       35,   35,    0,   21,   20,   27,    0,    0,   29,   25,
347       28,   17,   18,   19,    7,    8,    9,    1,   13,   14,
348       15,    0,    3,    4,    5,    0,    0,   35,   30,   26,
349        0,    0,    0,    2,   10,   11,   12,   31,   23,   22,
350       24,   32,    0,   33,    0,   34,    0
351    } ;
352
353static yyconst flex_int32_t yy_ec[256] =
354    {   0,
355        1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
356        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
357        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
358        1,    3,    1,    1,    4,    1,    1,    1,    1,    1,
359        1,    1,    5,    3,    6,    7,    1,    8,    8,    8,
360        8,    8,    8,    8,    8,    8,    8,    1,    1,    1,
361        1,    1,    1,    1,    1,    1,    1,    1,    9,    1,
362        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
363        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
364       10,    1,   11,    1,    1,    1,   12,   13,   14,   15,
365
366       16,   17,   18,   19,    1,    1,    1,    1,   20,    1,
367        1,   21,   22,   23,   24,   25,    1,    1,    1,   26,
368       27,   28,    1,    1,    1,    1,    1,    1,    1,    1,
369        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
370        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
371        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
372        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
373        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
374        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
375        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
376
377        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
378        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
379        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
380        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
381        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
382        1,    1,    1,    1,    1
383    } ;
384
385static yyconst flex_int32_t yy_meta[29] =
386    {   0,
387        1,    1,    1,    1,    1,    1,    1,    2,    1,    1,
388        1,    2,    2,    2,    2,    2,    2,    1,    1,    1,
389        1,    1,    1,    1,    1,    1,    1,    1
390    } ;
391
392static yyconst flex_int16_t yy_base[76] =
393    {   0,
394        0,    0,   93,   94,   94,   94,    0,   22,   24,   84,
395       26,   94,   94,   30,   10,   13,   34,   37,    0,   83,
396       50,   59,   45,   94,   72,   94,   65,   74,   94,   55,
397       94,   94,   94,   94,   94,   94,   94,   74,   94,   94,
398       94,   44,   94,   94,   94,    0,   78,   77,   94,   94,
399       71,   70,   63,   94,   94,   94,   94,    0,   94,   94,
400       94,    0,    0,    0,    0,   94,   94,   79,   78,   77,
401       76,   75,   72,   71,   54
402    } ;
403
404static yyconst flex_int16_t yy_def[76] =
405    {   0,
406       67,    1,   67,   67,   67,   67,   68,   67,   67,   67,
407       67,   67,   67,   67,   67,   67,   67,   67,   69,   67,
408       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
409       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
410       67,   67,   67,   67,   67,   70,   67,   67,   67,   67,
411       67,   67,   67,   67,   67,   67,   67,   71,   67,   67,
412       67,   72,   73,   74,   75,   67,    0,   67,   67,   67,
413       67,   67,   67,   67,   67
414    } ;
415
416static yyconst flex_int16_t yy_nxt[123] =
417    {   0,
418        4,    5,    6,    7,    8,    9,   10,   11,    4,   12,
419       13,   14,    4,    4,    4,    4,    4,    4,    4,   15,
420        4,    4,   16,   17,   18,    4,    4,    4,   20,   21,
421       20,   21,   20,   21,   23,   32,   33,   34,   35,   36,
422       37,   23,   24,   25,   26,   27,   28,   38,   42,   47,
423       47,   29,   48,   30,   31,   66,   20,   21,   23,   39,
424       40,   41,   43,   44,   45,   23,   22,   23,   52,   55,
425       56,   57,   65,   64,   23,   53,   63,   62,   58,   46,
426       19,   61,   60,   59,   48,   48,   54,   51,   50,   49,
427       22,   22,   67,    3,   67,   67,   67,   67,   67,   67,
428
429       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
430       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
431       67,   67
432    } ;
433
434static yyconst flex_int16_t yy_chk[123] =
435    {   0,
436        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
437        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
438        1,    1,    1,    1,    1,    1,    1,    1,    8,    8,
439        9,    9,   11,   11,   11,   15,   15,   15,   16,   16,
440       16,   11,   14,   14,   14,   14,   14,   17,   18,   23,
441       23,   14,   23,   14,   14,   75,   21,   21,   21,   17,
442       17,   17,   18,   18,   18,   21,   22,   22,   30,   42,
443       42,   42,   74,   73,   22,   30,   72,   71,   70,   69,
444       68,   53,   52,   51,   48,   47,   38,   28,   27,   25,
445       20,   10,    3,   67,   67,   67,   67,   67,   67,   67,
446
447       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
448       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
449       67,   67
450    } ;
451
452/* The intent behind this definition is that it'll catch
453 * any uses of REJECT which flex missed.
454 */
455#define REJECT reject_used_but_not_detected
456#define yymore() yymore_used_but_not_detected
457#define YY_MORE_ADJ 0
458#define YY_RESTORE_YY_MORE_OFFSET
459#line 1 "mesh-scanner.l"
460#line 2 "mesh-scanner.l"
461//
462// Orbital
463//
464// Copyright: (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
465//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
466//            (c) 2012 Sam Hocevar <sam@hocevar.net>
467//
468
469#if defined HAVE_CONFIG_H
470#   include "config.h"
471#endif
472
473#include "core.h"
474#include "loldebug.h"
475
476using namespace lol;
477
478#include "../mesh-compiler.h"
479
480typedef orbital::MeshParser::token token;
481typedef orbital::MeshParser::token_type token_type;
482
483#ifndef YY_DECL
484#   define YY_DECL orbital::MeshParser::token_type \
485        orbital::MeshScanner::lex(orbital::MeshParser::semantic_type* yylval, \
486                                  orbital::MeshParser::location_type* yylloc)
487#endif
488
489#define yyterminate() return token::T_END
490#define YY_NO_UNISTD_H
491#define YY_USER_ACTION yylloc->columns(yyleng);
492#line 493 "generated/mesh-scanner.cpp"
493
494#define INITIAL 0
495
496#ifndef YY_NO_UNISTD_H
497/* Special case for "unistd.h", since it is non-ANSI. We include it way
498 * down here because we want the user's section 1 to have been scanned first.
499 * The user has a chance to override it with an option.
500 */
501#include <unistd.h>
502#endif
503
504#ifndef YY_EXTRA_TYPE
505#define YY_EXTRA_TYPE void *
506#endif
507
508#ifndef yytext_ptr
509static void yy_flex_strncpy (char *,yyconst char *,int );
510#endif
511
512#ifdef YY_NEED_STRLEN
513static int yy_flex_strlen (yyconst char * );
514#endif
515
516#ifndef YY_NO_INPUT
517
518#endif
519
520/* Amount of stuff to slurp up with each read. */
521#ifndef YY_READ_BUF_SIZE
522#ifdef __ia64__
523/* On IA-64, the buffer size is 16k, not 8k */
524#define YY_READ_BUF_SIZE 16384
525#else
526#define YY_READ_BUF_SIZE 8192
527#endif /* __ia64__ */
528#endif
529
530/* Copy whatever the last rule matched to the standard output. */
531#ifndef ECHO
532#define ECHO LexerOutput( yytext, yyleng )
533#endif
534
535/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
536 * is returned in "result".
537 */
538#ifndef YY_INPUT
539#define YY_INPUT(buf,result,max_size) \
540\
541        if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
542                YY_FATAL_ERROR( "input in flex scanner failed" );
543
544#endif
545
546/* No semi-colon after return; correct usage is to write "yyterminate();" -
547 * we don't want an extra ';' after the "return" because that will cause
548 * some compilers to complain about unreachable statements.
549 */
550#ifndef yyterminate
551#define yyterminate() return YY_NULL
552#endif
553
554/* Number of entries by which start-condition stack grows. */
555#ifndef YY_START_STACK_INCR
556#define YY_START_STACK_INCR 25
557#endif
558
559/* Report a fatal error. */
560#ifndef YY_FATAL_ERROR
561#define YY_FATAL_ERROR(msg) LexerError( msg )
562#endif
563
564/* end tables serialization structures and prototypes */
565
566/* Default declaration of generated scanner - a define so the user can
567 * easily add parameters.
568 */
569#ifndef YY_DECL
570#define YY_DECL_IS_OURS 1
571#define YY_DECL int yyFlexLexer::yylex()
572#endif /* !YY_DECL */
573
574/* Code executed at the beginning of each rule, after yytext and yyleng
575 * have been set up.
576 */
577#ifndef YY_USER_ACTION
578#define YY_USER_ACTION
579#endif
580
581/* Code executed at the end of each rule. */
582#ifndef YY_BREAK
583#define YY_BREAK break;
584#endif
585
586#define YY_RULE_SETUP \
587        YY_USER_ACTION
588
589/** The main scanner function which does all the work.
590 */
591YY_DECL
592{
593        register yy_state_type yy_current_state;
594        register char *yy_cp, *yy_bp;
595        register int yy_act;
596   
597#line 38 "mesh-scanner.l"
598
599
600
601    /* reset location at the beginning of yylex() */
602    yylloc->step();
603
604
605#line 606 "generated/mesh-scanner.cpp"
606
607        if ( !(yy_init) )
608                {
609                (yy_init) = 1;
610
611#ifdef YY_USER_INIT
612                YY_USER_INIT;
613#endif
614
615                if ( ! (yy_start) )
616                        (yy_start) = 1; /* first start state */
617
618                if ( ! yyin )
619                        yyin = & std::cin;
620
621                if ( ! yyout )
622                        yyout = & std::cout;
623
624                if ( ! YY_CURRENT_BUFFER ) {
625                        yyensure_buffer_stack ();
626                        YY_CURRENT_BUFFER_LVALUE =
627                                yy_create_buffer( yyin, YY_BUF_SIZE );
628                }
629
630                yy_load_buffer_state(  );
631                }
632
633        while ( 1 )             /* loops until end-of-file is reached */
634                {
635                yy_cp = (yy_c_buf_p);
636
637                /* Support of yytext. */
638                *yy_cp = (yy_hold_char);
639
640                /* yy_bp points to the position in yy_ch_buf of the start of
641                 * the current run.
642                 */
643                yy_bp = yy_cp;
644
645                yy_current_state = (yy_start);
646yy_match:
647                do
648                        {
649                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
650                        if ( yy_accept[yy_current_state] )
651                                {
652                                (yy_last_accepting_state) = yy_current_state;
653                                (yy_last_accepting_cpos) = yy_cp;
654                                }
655                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
656                                {
657                                yy_current_state = (int) yy_def[yy_current_state];
658                                if ( yy_current_state >= 68 )
659                                        yy_c = yy_meta[(unsigned int) yy_c];
660                                }
661                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
662                        ++yy_cp;
663                        }
664                while ( yy_current_state != 67 );
665                yy_cp = (yy_last_accepting_cpos);
666                yy_current_state = (yy_last_accepting_state);
667
668yy_find_action:
669                yy_act = yy_accept[yy_current_state];
670
671                YY_DO_BEFORE_ACTION;
672
673do_action:      /* This label is used only to access EOF actions. */
674
675                switch ( yy_act )
676        { /* beginning of action switch */
677                        case 0: /* must back up */
678                        /* undo the effects of YY_DO_BEFORE_ACTION */
679                        *yy_cp = (yy_hold_char);
680                        yy_cp = (yy_last_accepting_cpos);
681                        yy_current_state = (yy_last_accepting_state);
682                        goto yy_find_action;
683
684case 1:
685YY_RULE_SETUP
686#line 45 "mesh-scanner.l"
687{ return token::T_COLOR; }
688        YY_BREAK
689case 2:
690YY_RULE_SETUP
691#line 46 "mesh-scanner.l"
692{ return token::T_BGCOLOR; }
693        YY_BREAK
694case 3:
695YY_RULE_SETUP
696#line 48 "mesh-scanner.l"
697{ return token::T_TRANSLATEX; }
698        YY_BREAK
699case 4:
700YY_RULE_SETUP
701#line 49 "mesh-scanner.l"
702{ return token::T_TRANSLATEY; }
703        YY_BREAK
704case 5:
705YY_RULE_SETUP
706#line 50 "mesh-scanner.l"
707{ return token::T_TRANSLATEZ; }
708        YY_BREAK
709case 6:
710YY_RULE_SETUP
711#line 51 "mesh-scanner.l"
712{ return token::T_TRANSLATE; }
713        YY_BREAK
714case 7:
715YY_RULE_SETUP
716#line 52 "mesh-scanner.l"
717{ return token::T_ROTATEX; }
718        YY_BREAK
719case 8:
720YY_RULE_SETUP
721#line 53 "mesh-scanner.l"
722{ return token::T_ROTATEY; }
723        YY_BREAK
724case 9:
725YY_RULE_SETUP
726#line 54 "mesh-scanner.l"
727{ return token::T_ROTATEZ; }
728        YY_BREAK
729case 10:
730YY_RULE_SETUP
731#line 55 "mesh-scanner.l"
732{ return token::T_TAPERX; }
733        YY_BREAK
734case 11:
735YY_RULE_SETUP
736#line 56 "mesh-scanner.l"
737{ return token::T_TAPERY; }
738        YY_BREAK
739case 12:
740YY_RULE_SETUP
741#line 57 "mesh-scanner.l"
742{ return token::T_TAPERZ; }
743        YY_BREAK
744case 13:
745YY_RULE_SETUP
746#line 58 "mesh-scanner.l"
747{ return token::T_SCALEX; }
748        YY_BREAK
749case 14:
750YY_RULE_SETUP
751#line 59 "mesh-scanner.l"
752{ return token::T_SCALEY; }
753        YY_BREAK
754case 15:
755YY_RULE_SETUP
756#line 60 "mesh-scanner.l"
757{ return token::T_SCALEZ; }
758        YY_BREAK
759case 16:
760YY_RULE_SETUP
761#line 61 "mesh-scanner.l"
762{ return token::T_SCALE; }
763        YY_BREAK
764case 17:
765YY_RULE_SETUP
766#line 62 "mesh-scanner.l"
767{ return token::T_MIRRORX; }
768        YY_BREAK
769case 18:
770YY_RULE_SETUP
771#line 63 "mesh-scanner.l"
772{ return token::T_MIRRORY; }
773        YY_BREAK
774case 19:
775YY_RULE_SETUP
776#line 64 "mesh-scanner.l"
777{ return token::T_MIRRORZ; }
778        YY_BREAK
779case 20:
780YY_RULE_SETUP
781#line 66 "mesh-scanner.l"
782{ return token::T_CYLINDER; }
783        YY_BREAK
784case 21:
785YY_RULE_SETUP
786#line 67 "mesh-scanner.l"
787{ return token::T_BOX; }
788        YY_BREAK
789case 22:
790YY_RULE_SETUP
791#line 68 "mesh-scanner.l"
792{ return token::T_SMOOTHCHAMFBOX; }
793        YY_BREAK
794case 23:
795YY_RULE_SETUP
796#line 69 "mesh-scanner.l"
797{ return token::T_FLATCHAMFBOX; }
798        YY_BREAK
799case 24:
800YY_RULE_SETUP
801#line 70 "mesh-scanner.l"
802{ return token::T_SPHERE; }
803        YY_BREAK
804case 25:
805YY_RULE_SETUP
806#line 71 "mesh-scanner.l"
807{ return token::T_STAR; }
808        YY_BREAK
809case 26:
810YY_RULE_SETUP
811#line 72 "mesh-scanner.l"
812{ return token::T_EXPANDEDSTAR; }
813        YY_BREAK
814case 27:
815YY_RULE_SETUP
816#line 73 "mesh-scanner.l"
817{ return token::T_DISC; }
818        YY_BREAK
819case 28:
820YY_RULE_SETUP
821#line 74 "mesh-scanner.l"
822{ return token::T_TRIANGLE; }
823        YY_BREAK
824case 29:
825YY_RULE_SETUP
826#line 75 "mesh-scanner.l"
827{ return token::T_QUAD; }
828        YY_BREAK
829case 30:
830YY_RULE_SETUP
831#line 76 "mesh-scanner.l"
832{ return token::T_COG; }
833        YY_BREAK
834case 31:
835YY_RULE_SETUP
836#line 78 "mesh-scanner.l"
837{
838        uint32_t tmp = strtol(yytext + 1, NULL, 16);
839        yylval->u32val = 0x11000000u * (tmp >> 8)
840                       | 0x00110000u * ((tmp >> 4) & 0xf)
841                       | 0x00001100u * (tmp & 0xf)
842                       | 0x000000ffu;
843        return token::COLOR; }
844        YY_BREAK
845case 32:
846YY_RULE_SETUP
847#line 85 "mesh-scanner.l"
848{
849        uint32_t tmp = strtol(yytext + 1, NULL, 16);
850        yylval->u32val = 0x11000000u * (tmp >> 12)
851                       | 0x00110000u * ((tmp >> 8) & 0xf)
852                       | 0x00001100u * ((tmp >> 4) & 0xf)
853                       | 0x00000011u * (tmp & 0xf);
854        return token::COLOR; }
855        YY_BREAK
856case 33:
857YY_RULE_SETUP
858#line 92 "mesh-scanner.l"
859{
860        yylval->u32val = 0xffu
861                       | 0x100u * (uint32_t)strtol(yytext + 1, NULL, 16);
862        return token::COLOR; }
863        YY_BREAK
864case 34:
865YY_RULE_SETUP
866#line 96 "mesh-scanner.l"
867{
868        yylval->u32val = (uint32_t)strtol(yytext + 1, NULL, 16);
869        return token::COLOR; }
870        YY_BREAK
871case 35:
872YY_RULE_SETUP
873#line 99 "mesh-scanner.l"
874{
875        yylval->fval = atof(yytext); return token::NUMBER; }
876        YY_BREAK
877case 36:
878YY_RULE_SETUP
879#line 101 "mesh-scanner.l"
880{ return token_type('-'); }
881        YY_BREAK
882case 37:
883YY_RULE_SETUP
884#line 102 "mesh-scanner.l"
885{ return token_type('['); }
886        YY_BREAK
887case 38:
888YY_RULE_SETUP
889#line 103 "mesh-scanner.l"
890{ return token_type(']'); }
891        YY_BREAK
892case 39:
893YY_RULE_SETUP
894#line 104 "mesh-scanner.l"
895{ /* ignore this */ }
896        YY_BREAK
897case 40:
898/* rule 40 can match eol */
899YY_RULE_SETUP
900#line 105 "mesh-scanner.l"
901{ /* ignore this */ }
902        YY_BREAK
903case 41:
904YY_RULE_SETUP
905#line 106 "mesh-scanner.l"
906{ return token::T_ERROR; }
907        YY_BREAK
908case 42:
909YY_RULE_SETUP
910#line 108 "mesh-scanner.l"
911ECHO;
912        YY_BREAK
913#line 914 "generated/mesh-scanner.cpp"
914case YY_STATE_EOF(INITIAL):
915        yyterminate();
916
917        case YY_END_OF_BUFFER:
918                {
919                /* Amount of text matched not including the EOB char. */
920                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
921
922                /* Undo the effects of YY_DO_BEFORE_ACTION. */
923                *yy_cp = (yy_hold_char);
924                YY_RESTORE_YY_MORE_OFFSET
925
926                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
927                        {
928                        /* We're scanning a new file or input source.  It's
929                         * possible that this happened because the user
930                         * just pointed yyin at a new source and called
931                         * yylex().  If so, then we have to assure
932                         * consistency between YY_CURRENT_BUFFER and our
933                         * globals.  Here is the right place to do so, because
934                         * this is the first action (other than possibly a
935                         * back-up) that will match for the new input source.
936                         */
937                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
938                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
939                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
940                        }
941
942                /* Note that here we test for yy_c_buf_p "<=" to the position
943                 * of the first EOB in the buffer, since yy_c_buf_p will
944                 * already have been incremented past the NUL character
945                 * (since all states make transitions on EOB to the
946                 * end-of-buffer state).  Contrast this with the test
947                 * in input().
948                 */
949                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
950                        { /* This was really a NUL. */
951                        yy_state_type yy_next_state;
952
953                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
954
955                        yy_current_state = yy_get_previous_state(  );
956
957                        /* Okay, we're now positioned to make the NUL
958                         * transition.  We couldn't have
959                         * yy_get_previous_state() go ahead and do it
960                         * for us because it doesn't know how to deal
961                         * with the possibility of jamming (and we don't
962                         * want to build jamming into it because then it
963                         * will run more slowly).
964                         */
965
966                        yy_next_state = yy_try_NUL_trans( yy_current_state );
967
968                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
969
970                        if ( yy_next_state )
971                                {
972                                /* Consume the NUL. */
973                                yy_cp = ++(yy_c_buf_p);
974                                yy_current_state = yy_next_state;
975                                goto yy_match;
976                                }
977
978                        else
979                                {
980                                yy_cp = (yy_last_accepting_cpos);
981                                yy_current_state = (yy_last_accepting_state);
982                                goto yy_find_action;
983                                }
984                        }
985
986                else switch ( yy_get_next_buffer(  ) )
987                        {
988                        case EOB_ACT_END_OF_FILE:
989                                {
990                                (yy_did_buffer_switch_on_eof) = 0;
991
992                                if ( yywrap(  ) )
993                                        {
994                                        /* Note: because we've taken care in
995                                         * yy_get_next_buffer() to have set up
996                                         * yytext, we can now set up
997                                         * yy_c_buf_p so that if some total
998                                         * hoser (like flex itself) wants to
999                                         * call the scanner after we return the
1000                                         * YY_NULL, it'll still work - another
1001                                         * YY_NULL will get returned.
1002                                         */
1003                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1004
1005                                        yy_act = YY_STATE_EOF(YY_START);
1006                                        goto do_action;
1007                                        }
1008
1009                                else
1010                                        {
1011                                        if ( ! (yy_did_buffer_switch_on_eof) )
1012                                                YY_NEW_FILE;
1013                                        }
1014                                break;
1015                                }
1016
1017                        case EOB_ACT_CONTINUE_SCAN:
1018                                (yy_c_buf_p) =
1019                                        (yytext_ptr) + yy_amount_of_matched_text;
1020
1021                                yy_current_state = yy_get_previous_state(  );
1022
1023                                yy_cp = (yy_c_buf_p);
1024                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1025                                goto yy_match;
1026
1027                        case EOB_ACT_LAST_MATCH:
1028                                (yy_c_buf_p) =
1029                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1030
1031                                yy_current_state = yy_get_previous_state(  );
1032
1033                                yy_cp = (yy_c_buf_p);
1034                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1035                                goto yy_find_action;
1036                        }
1037                break;
1038                }
1039
1040        default:
1041                YY_FATAL_ERROR(
1042                        "fatal flex scanner internal error--no action found" );
1043        } /* end of action switch */
1044                } /* end of scanning one token */
1045} /* end of yylex */
1046
1047/* The contents of this function are C++ specific, so the () macro is not used.
1048 */
1049yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1050{
1051        yyin = arg_yyin;
1052        yyout = arg_yyout;
1053        yy_c_buf_p = 0;
1054        yy_init = 0;
1055        yy_start = 0;
1056        yy_flex_debug = 0;
1057        yylineno = 1;   // this will only get updated if %option yylineno
1058
1059        yy_did_buffer_switch_on_eof = 0;
1060
1061        yy_looking_for_trail_begin = 0;
1062        yy_more_flag = 0;
1063        yy_more_len = 0;
1064        yy_more_offset = yy_prev_more_offset = 0;
1065
1066        yy_start_stack_ptr = yy_start_stack_depth = 0;
1067        yy_start_stack = NULL;
1068
1069        yy_buffer_stack = 0;
1070        yy_buffer_stack_top = 0;
1071        yy_buffer_stack_max = 0;
1072
1073        yy_state_buf = 0;
1074
1075}
1076
1077/* The contents of this function are C++ specific, so the () macro is not used.
1078 */
1079yyFlexLexer::~yyFlexLexer()
1080{
1081        delete [] yy_state_buf;
1082        Meshfree(yy_start_stack  );
1083        yy_delete_buffer( YY_CURRENT_BUFFER );
1084        Meshfree(yy_buffer_stack  );
1085}
1086
1087/* The contents of this function are C++ specific, so the () macro is not used.
1088 */
1089void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1090{
1091        if ( new_in )
1092                {
1093                yy_delete_buffer( YY_CURRENT_BUFFER );
1094                yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  ) );
1095                }
1096
1097        if ( new_out )
1098                yyout = new_out;
1099}
1100
1101#ifdef YY_INTERACTIVE
1102int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
1103#else
1104int yyFlexLexer::LexerInput( char* buf, int max_size )
1105#endif
1106{
1107        if ( yyin->eof() || yyin->fail() )
1108                return 0;
1109
1110#ifdef YY_INTERACTIVE
1111        yyin->get( buf[0] );
1112
1113        if ( yyin->eof() )
1114                return 0;
1115
1116        if ( yyin->bad() )
1117                return -1;
1118
1119        return 1;
1120
1121#else
1122        (void) yyin->read( buf, max_size );
1123
1124        if ( yyin->bad() )
1125                return -1;
1126        else
1127                return yyin->gcount();
1128#endif
1129}
1130
1131void yyFlexLexer::LexerOutput( const char* buf, int size )
1132{
1133        (void) yyout->write( buf, size );
1134}
1135
1136/* yy_get_next_buffer - try to read in a new buffer
1137 *
1138 * Returns a code representing an action:
1139 *      EOB_ACT_LAST_MATCH -
1140 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1141 *      EOB_ACT_END_OF_FILE - end of file
1142 */
1143int yyFlexLexer::yy_get_next_buffer()
1144{
1145        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1146        register char *source = (yytext_ptr);
1147        register int number_to_move, i;
1148        int ret_val;
1149
1150        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1151                YY_FATAL_ERROR(
1152                "fatal flex scanner internal error--end of buffer missed" );
1153
1154        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1155                { /* Don't try to fill the buffer, so this is an EOF. */
1156                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1157                        {
1158                        /* We matched a single character, the EOB, so
1159                         * treat this as a final EOF.
1160                         */
1161                        return EOB_ACT_END_OF_FILE;
1162                        }
1163
1164                else
1165                        {
1166                        /* We matched some text prior to the EOB, first
1167                         * process it.
1168                         */
1169                        return EOB_ACT_LAST_MATCH;
1170                        }
1171                }
1172
1173        /* Try to read more data. */
1174
1175        /* First move last chars to start of buffer. */
1176        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1177
1178        for ( i = 0; i < number_to_move; ++i )
1179                *(dest++) = *(source++);
1180
1181        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1182                /* don't do the read, it's not guaranteed to return an EOF,
1183                 * just force an EOF
1184                 */
1185                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1186
1187        else
1188                {
1189                        int num_to_read =
1190                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1191
1192                while ( num_to_read <= 0 )
1193                        { /* Not enough room in the buffer - grow it. */
1194
1195                        /* just a shorter name for the current buffer */
1196                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1197
1198                        int yy_c_buf_p_offset =
1199                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1200
1201                        if ( b->yy_is_our_buffer )
1202                                {
1203                                int new_size = b->yy_buf_size * 2;
1204
1205                                if ( new_size <= 0 )
1206                                        b->yy_buf_size += b->yy_buf_size / 8;
1207                                else
1208                                        b->yy_buf_size *= 2;
1209
1210                                b->yy_ch_buf = (char *)
1211                                        /* Include room in for 2 EOB chars. */
1212                                        Meshrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1213                                }
1214                        else
1215                                /* Can't grow it, we don't own it. */
1216                                b->yy_ch_buf = 0;
1217
1218                        if ( ! b->yy_ch_buf )
1219                                YY_FATAL_ERROR(
1220                                "fatal error - scanner input buffer overflow" );
1221
1222                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1223
1224                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1225                                                number_to_move - 1;
1226
1227                        }
1228
1229                if ( num_to_read > YY_READ_BUF_SIZE )
1230                        num_to_read = YY_READ_BUF_SIZE;
1231
1232                /* Read in more data. */
1233                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1234                        (yy_n_chars), (size_t) num_to_read );
1235
1236                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1237                }
1238
1239        if ( (yy_n_chars) == 0 )
1240                {
1241                if ( number_to_move == YY_MORE_ADJ )
1242                        {
1243                        ret_val = EOB_ACT_END_OF_FILE;
1244                        yyrestart( yyin  );
1245                        }
1246
1247                else
1248                        {
1249                        ret_val = EOB_ACT_LAST_MATCH;
1250                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1251                                YY_BUFFER_EOF_PENDING;
1252                        }
1253                }
1254
1255        else
1256                ret_val = EOB_ACT_CONTINUE_SCAN;
1257
1258        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1259                /* Extend the array by 50%, plus the number we really need. */
1260                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1261                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) Meshrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1262                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1263                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1264        }
1265
1266        (yy_n_chars) += number_to_move;
1267        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1268        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1269
1270        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1271
1272        return ret_val;
1273}
1274
1275/* yy_get_previous_state - get the state just before the EOB char was reached */
1276
1277    yy_state_type yyFlexLexer::yy_get_previous_state()
1278{
1279        register yy_state_type yy_current_state;
1280        register char *yy_cp;
1281   
1282        yy_current_state = (yy_start);
1283
1284        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1285                {
1286                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1287                if ( yy_accept[yy_current_state] )
1288                        {
1289                        (yy_last_accepting_state) = yy_current_state;
1290                        (yy_last_accepting_cpos) = yy_cp;
1291                        }
1292                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1293                        {
1294                        yy_current_state = (int) yy_def[yy_current_state];
1295                        if ( yy_current_state >= 68 )
1296                                yy_c = yy_meta[(unsigned int) yy_c];
1297                        }
1298                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1299                }
1300
1301        return yy_current_state;
1302}
1303
1304/* yy_try_NUL_trans - try to make a transition on the NUL character
1305 *
1306 * synopsis
1307 *      next_state = yy_try_NUL_trans( current_state );
1308 */
1309    yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
1310{
1311        register int yy_is_jam;
1312        register char *yy_cp = (yy_c_buf_p);
1313
1314        register YY_CHAR yy_c = 1;
1315        if ( yy_accept[yy_current_state] )
1316                {
1317                (yy_last_accepting_state) = yy_current_state;
1318                (yy_last_accepting_cpos) = yy_cp;
1319                }
1320        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1321                {
1322                yy_current_state = (int) yy_def[yy_current_state];
1323                if ( yy_current_state >= 68 )
1324                        yy_c = yy_meta[(unsigned int) yy_c];
1325                }
1326        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1327        yy_is_jam = (yy_current_state == 67);
1328
1329        return yy_is_jam ? 0 : yy_current_state;
1330}
1331
1332    void yyFlexLexer::yyunput( int c, register char* yy_bp)
1333{
1334        register char *yy_cp;
1335   
1336    yy_cp = (yy_c_buf_p);
1337
1338        /* undo effects of setting up yytext */
1339        *yy_cp = (yy_hold_char);
1340
1341        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1342                { /* need to shift things up to make room */
1343                /* +2 for EOB chars. */
1344                register int number_to_move = (yy_n_chars) + 2;
1345                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1346                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1347                register char *source =
1348                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1349
1350                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1351                        *--dest = *--source;
1352
1353                yy_cp += (int) (dest - source);
1354                yy_bp += (int) (dest - source);
1355                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1356                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1357
1358                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1359                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1360                }
1361
1362        *--yy_cp = (char) c;
1363
1364        (yytext_ptr) = yy_bp;
1365        (yy_hold_char) = *yy_cp;
1366        (yy_c_buf_p) = yy_cp;
1367}
1368
1369    int yyFlexLexer::yyinput()
1370{
1371        int c;
1372   
1373        *(yy_c_buf_p) = (yy_hold_char);
1374
1375        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1376                {
1377                /* yy_c_buf_p now points to the character we want to return.
1378                 * If this occurs *before* the EOB characters, then it's a
1379                 * valid NUL; if not, then we've hit the end of the buffer.
1380                 */
1381                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1382                        /* This was really a NUL. */
1383                        *(yy_c_buf_p) = '\0';
1384
1385                else
1386                        { /* need more input */
1387                        int offset = (yy_c_buf_p) - (yytext_ptr);
1388                        ++(yy_c_buf_p);
1389
1390                        switch ( yy_get_next_buffer(  ) )
1391                                {
1392                                case EOB_ACT_LAST_MATCH:
1393                                        /* This happens because yy_g_n_b()
1394                                         * sees that we've accumulated a
1395                                         * token and flags that we need to
1396                                         * try matching the token before
1397                                         * proceeding.  But for input(),
1398                                         * there's no matching to consider.
1399                                         * So convert the EOB_ACT_LAST_MATCH
1400                                         * to EOB_ACT_END_OF_FILE.
1401                                         */
1402
1403                                        /* Reset buffer status. */
1404                                        yyrestart( yyin );
1405
1406                                        /*FALLTHROUGH*/
1407
1408                                case EOB_ACT_END_OF_FILE:
1409                                        {
1410                                        if ( yywrap(  ) )
1411                                                return EOF;
1412
1413                                        if ( ! (yy_did_buffer_switch_on_eof) )
1414                                                YY_NEW_FILE;
1415#ifdef __cplusplus
1416                                        return yyinput();
1417#else
1418                                        return input();
1419#endif
1420                                        }
1421
1422                                case EOB_ACT_CONTINUE_SCAN:
1423                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1424                                        break;
1425                                }
1426                        }
1427                }
1428
1429        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1430        *(yy_c_buf_p) = '\0';   /* preserve yytext */
1431        (yy_hold_char) = *++(yy_c_buf_p);
1432
1433        return c;
1434}
1435
1436/** Immediately switch to a different input stream.
1437 * @param input_file A readable stream.
1438 *
1439 * @note This function does not reset the start condition to @c INITIAL .
1440 */
1441    void yyFlexLexer::yyrestart( std::istream* input_file )
1442{
1443   
1444        if ( ! YY_CURRENT_BUFFER ){
1445        yyensure_buffer_stack ();
1446                YY_CURRENT_BUFFER_LVALUE =
1447            yy_create_buffer( yyin, YY_BUF_SIZE );
1448        }
1449
1450        yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1451        yy_load_buffer_state(  );
1452}
1453
1454/** Switch to a different input buffer.
1455 * @param new_buffer The new input buffer.
1456 *
1457 */
1458    void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1459{
1460   
1461        /* TODO. We should be able to replace this entire function body
1462         * with
1463         *              yypop_buffer_state();
1464         *              yypush_buffer_state(new_buffer);
1465     */
1466        yyensure_buffer_stack ();
1467        if ( YY_CURRENT_BUFFER == new_buffer )
1468                return;
1469
1470        if ( YY_CURRENT_BUFFER )
1471                {
1472                /* Flush out information for old buffer. */
1473                *(yy_c_buf_p) = (yy_hold_char);
1474                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1475                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1476                }
1477
1478        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1479        yy_load_buffer_state(  );
1480
1481        /* We don't actually know whether we did this switch during
1482         * EOF (yywrap()) processing, but the only time this flag
1483         * is looked at is after yywrap() is called, so it's safe
1484         * to go ahead and always set it.
1485         */
1486        (yy_did_buffer_switch_on_eof) = 1;
1487}
1488
1489    void yyFlexLexer::yy_load_buffer_state()
1490{
1491        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1492        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1493        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1494        (yy_hold_char) = *(yy_c_buf_p);
1495}
1496
1497/** Allocate and initialize an input buffer state.
1498 * @param file A readable stream.
1499 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1500 *
1501 * @return the allocated buffer state.
1502 */
1503    YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
1504{
1505        YY_BUFFER_STATE b;
1506   
1507        b = (YY_BUFFER_STATE) Meshalloc(sizeof( struct yy_buffer_state )  );
1508        if ( ! b )
1509                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1510
1511        b->yy_buf_size = size;
1512
1513        /* yy_ch_buf has to be 2 characters longer than the size given because
1514         * we need to put in 2 end-of-buffer characters.
1515         */
1516        b->yy_ch_buf = (char *) Meshalloc(b->yy_buf_size + 2  );
1517        if ( ! b->yy_ch_buf )
1518                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1519
1520        b->yy_is_our_buffer = 1;
1521
1522        yy_init_buffer( b, file );
1523
1524        return b;
1525}
1526
1527/** Destroy the buffer.
1528 * @param b a buffer created with yy_create_buffer()
1529 *
1530 */
1531    void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
1532{
1533   
1534        if ( ! b )
1535                return;
1536
1537        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1538                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1539
1540        if ( b->yy_is_our_buffer )
1541                Meshfree((void *) b->yy_ch_buf  );
1542
1543        Meshfree((void *) b  );
1544}
1545
1546extern "C" int isatty (int );
1547
1548/* Initializes or reinitializes a buffer.
1549 * This function is sometimes called more than once on the same buffer,
1550 * such as during a yyrestart() or at EOF.
1551 */
1552    void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
1553
1554{
1555        int oerrno = errno;
1556   
1557        yy_flush_buffer( b );
1558
1559        b->yy_input_file = file;
1560        b->yy_fill_buffer = 1;
1561
1562    /* If b is the current buffer, then yy_init_buffer was _probably_
1563     * called from yyrestart() or through yy_get_next_buffer.
1564     * In that case, we don't want to reset the lineno or column.
1565     */
1566    if (b != YY_CURRENT_BUFFER){
1567        b->yy_bs_lineno = 1;
1568        b->yy_bs_column = 0;
1569    }
1570
1571        b->yy_is_interactive = 0;
1572        errno = oerrno;
1573}
1574
1575/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1576 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1577 *
1578 */
1579    void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
1580{
1581        if ( ! b )
1582                return;
1583
1584        b->yy_n_chars = 0;
1585
1586        /* We always need two end-of-buffer characters.  The first causes
1587         * a transition to the end-of-buffer state.  The second causes
1588         * a jam in that state.
1589         */
1590        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1591        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1592
1593        b->yy_buf_pos = &b->yy_ch_buf[0];
1594
1595        b->yy_at_bol = 1;
1596        b->yy_buffer_status = YY_BUFFER_NEW;
1597
1598        if ( b == YY_CURRENT_BUFFER )
1599                yy_load_buffer_state(  );
1600}
1601
1602/** Pushes the new state onto the stack. The new state becomes
1603 *  the current state. This function will allocate the stack
1604 *  if necessary.
1605 *  @param new_buffer The new state.
1606 * 
1607 */
1608void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
1609{
1610        if (new_buffer == NULL)
1611                return;
1612
1613        yyensure_buffer_stack();
1614
1615        /* This block is copied from yy_switch_to_buffer. */
1616        if ( YY_CURRENT_BUFFER )
1617                {
1618                /* Flush out information for old buffer. */
1619                *(yy_c_buf_p) = (yy_hold_char);
1620                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1621                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1622                }
1623
1624        /* Only push if top exists. Otherwise, replace top. */
1625        if (YY_CURRENT_BUFFER)
1626                (yy_buffer_stack_top)++;
1627        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1628
1629        /* copied from yy_switch_to_buffer. */
1630        yy_load_buffer_state(  );
1631        (yy_did_buffer_switch_on_eof) = 1;
1632}
1633
1634/** Removes and deletes the top of the stack, if present.
1635 *  The next element becomes the new top.
1636 * 
1637 */
1638void yyFlexLexer::yypop_buffer_state (void)
1639{
1640        if (!YY_CURRENT_BUFFER)
1641                return;
1642
1643        yy_delete_buffer(YY_CURRENT_BUFFER );
1644        YY_CURRENT_BUFFER_LVALUE = NULL;
1645        if ((yy_buffer_stack_top) > 0)
1646                --(yy_buffer_stack_top);
1647
1648        if (YY_CURRENT_BUFFER) {
1649                yy_load_buffer_state(  );
1650                (yy_did_buffer_switch_on_eof) = 1;
1651        }
1652}
1653
1654/* Allocates the stack if it does not exist.
1655 *  Guarantees space for at least one push.
1656 */
1657void yyFlexLexer::yyensure_buffer_stack(void)
1658{
1659        int num_to_alloc;
1660   
1661        if (!(yy_buffer_stack)) {
1662
1663                /* First allocation is just for 2 elements, since we don't know if this
1664                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1665                 * immediate realloc on the next call.
1666         */
1667                num_to_alloc = 1;
1668                (yy_buffer_stack) = (struct yy_buffer_state**)Meshalloc
1669                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
1670                                                                );
1671                if ( ! (yy_buffer_stack) )
1672                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1673                                                                 
1674                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1675                               
1676                (yy_buffer_stack_max) = num_to_alloc;
1677                (yy_buffer_stack_top) = 0;
1678                return;
1679        }
1680
1681        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1682
1683                /* Increase the buffer to prepare for a possible push. */
1684                int grow_size = 8 /* arbitrary grow size */;
1685
1686                num_to_alloc = (yy_buffer_stack_max) + grow_size;
1687                (yy_buffer_stack) = (struct yy_buffer_state**)Meshrealloc
1688                                                                ((yy_buffer_stack),
1689                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
1690                                                                );
1691                if ( ! (yy_buffer_stack) )
1692                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1693
1694                /* zero only the new slots.*/
1695                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1696                (yy_buffer_stack_max) = num_to_alloc;
1697        }
1698}
1699
1700    void yyFlexLexer::yy_push_state( int new_state )
1701{
1702        if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
1703                {
1704                yy_size_t new_size;
1705
1706                (yy_start_stack_depth) += YY_START_STACK_INCR;
1707                new_size = (yy_start_stack_depth) * sizeof( int );
1708
1709                if ( ! (yy_start_stack) )
1710                        (yy_start_stack) = (int *) Meshalloc(new_size  );
1711
1712                else
1713                        (yy_start_stack) = (int *) Meshrealloc((void *) (yy_start_stack),new_size  );
1714
1715                if ( ! (yy_start_stack) )
1716                        YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
1717                }
1718
1719        (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
1720
1721        BEGIN(new_state);
1722}
1723
1724    void yyFlexLexer::yy_pop_state()
1725{
1726        if ( --(yy_start_stack_ptr) < 0 )
1727                YY_FATAL_ERROR( "start-condition stack underflow" );
1728
1729        BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
1730}
1731
1732    int yyFlexLexer::yy_top_state()
1733{
1734        return (yy_start_stack)[(yy_start_stack_ptr) - 1];
1735}
1736
1737#ifndef YY_EXIT_FAILURE
1738#define YY_EXIT_FAILURE 2
1739#endif
1740
1741void yyFlexLexer::LexerError( yyconst char msg[] )
1742{
1743        std::cerr << msg << std::endl;
1744        exit( YY_EXIT_FAILURE );
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        int yyless_macro_arg = (n); \
1755        YY_LESS_LINENO(yyless_macro_arg);\
1756                yytext[yyleng] = (yy_hold_char); \
1757                (yy_c_buf_p) = yytext + yyless_macro_arg; \
1758                (yy_hold_char) = *(yy_c_buf_p); \
1759                *(yy_c_buf_p) = '\0'; \
1760                yyleng = yyless_macro_arg; \
1761                } \
1762        while ( 0 )
1763
1764/* Accessor  methods (get/set functions) to struct members. */
1765
1766/*
1767 * Internal utility routines.
1768 */
1769
1770#ifndef yytext_ptr
1771static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1772{
1773        register int i;
1774        for ( i = 0; i < n; ++i )
1775                s1[i] = s2[i];
1776}
1777#endif
1778
1779#ifdef YY_NEED_STRLEN
1780static int yy_flex_strlen (yyconst char * s )
1781{
1782        register int n;
1783        for ( n = 0; s[n]; ++n )
1784                ;
1785
1786        return n;
1787}
1788#endif
1789
1790void *Meshalloc (yy_size_t  size )
1791{
1792        return (void *) malloc( size );
1793}
1794
1795void *Meshrealloc  (void * ptr, yy_size_t  size )
1796{
1797        /* The cast to (char *) in the following accommodates both
1798         * implementations that use char* generic pointers, and those
1799         * that use void* generic pointers.  It works with the latter
1800         * because both ANSI C and C++ allow castless assignment from
1801         * any pointer type to void*, and deal with argument conversions
1802         * as though doing an assignment.
1803         */
1804        return (void *) realloc( (char *) ptr, size );
1805}
1806
1807void Meshfree (void * ptr )
1808{
1809        free( (char *) ptr );   /* see Meshrealloc() for (char *) cast */
1810}
1811
1812#define YYTABLES_NAME "yytables"
1813
1814#line 108 "mesh-scanner.l"
1815
1816
1817
1818orbital::MeshScanner::MeshScanner(char const *command)
1819    : MeshFlexLexer(0, 0),
1820      m_input(command)
1821{
1822}
1823
1824orbital::MeshScanner::~MeshScanner()
1825{
1826}
1827
1828int orbital::MeshScanner::LexerInput(char* buf, int max_size)
1829{
1830    buf[0] = m_input[0];
1831    if (buf[0])
1832        ++m_input;
1833    return buf[0] ? 1 : 0;
1834}
1835
1836#ifdef yylex
1837#undef yylex
1838#endif
1839int MeshFlexLexer::yylex()
1840{
1841    std::cerr << "in MeshFlexLexer::yylex() !" << std::endl;
1842    return 0;
1843}
1844
1845int MeshFlexLexer::yywrap()
1846{
1847    return 1;
1848}
1849
1850
Note: See TracBrowser for help on using the repository browser.