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

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

orbital: allow hexadecimal colour values.

  • Property svn:keywords set to Id
File size: 45.7 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 39
334#define YY_END_OF_BUFFER 40
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[69] =
343    {   0,
344        0,    0,   40,   39,   38,   39,   39,   37,   36,   38,
345       35,   39,   39,   39,   39,   39,   19,    9,    0,    0,
346       35,   35,    0,   24,   23,   30,    0,    0,   32,   28,
347       31,    1,    0,    0,   20,   21,   22,   10,   11,   12,
348        4,   16,   17,   18,    0,    6,    7,    8,    0,    0,
349       35,   33,   29,    0,    0,    0,    3,    2,    5,   13,
350       14,   15,    0,   26,   25,   27,   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,    1,    1,    1,    3,    1,    1,    1,    1,    1,
359        1,    1,    4,    5,    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        1,    1,    1,    1,    1,    1,   10,   11,   12,   13,
365
366       14,   15,   16,   17,   18,    1,    1,   19,   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,    2,
388        2,    2,    2,    2,    2,    1,    1,    1,    1,    1,
389        1,    1,    1,    1,    1,    1,    1,    1
390    } ;
391
392static yyconst flex_int16_t yy_base[73] =
393    {   0,
394        0,    0,   94,   95,   95,    0,   22,   95,   24,   85,
395       26,   30,   27,   69,   10,   21,   39,   43,    0,   83,
396       49,   64,   56,   95,   74,   95,   65,   76,   95,   47,
397       95,   95,   76,   75,   95,   95,   95,   95,   95,   95,
398       74,   95,   95,   95,   48,   95,   95,   95,    0,   76,
399       75,   95,   95,   71,   70,   63,   95,   95,   95,   95,
400       95,   95,    0,   95,   95,   95,   95,   95,   77,   75,
401       59,   37
402    } ;
403
404static yyconst flex_int16_t yy_def[73] =
405    {   0,
406       68,    1,   68,   68,   68,   69,   68,   68,   68,   68,
407       68,   68,   68,   68,   68,   68,   68,   68,   70,   68,
408       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
409       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
410       68,   68,   68,   68,   68,   68,   68,   68,   71,   68,
411       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
412       68,   68,   72,   68,   68,   68,   68,    0,   68,   68,
413       68,   68
414    } ;
415
416static yyconst flex_int16_t yy_nxt[124] =
417    {   0,
418        4,    5,    6,    7,    8,    9,   10,   11,    4,   12,
419        4,    4,    4,    4,   13,    4,    4,   14,    4,   15,
420        4,    4,   16,   17,   18,    4,    4,    4,   20,   21,
421       20,   21,   20,   21,   23,   35,   36,   37,   67,   23,
422       24,   25,   26,   27,   28,   32,   38,   39,   40,   33,
423       41,   29,   45,   30,   31,   20,   21,   23,   55,   50,
424       63,   50,   23,   51,   42,   43,   44,   56,   46,   47,
425       48,   22,   23,   60,   61,   62,   49,   23,   19,   66,
426       65,   64,   51,   51,   59,   58,   57,   54,   53,   52,
427       22,   34,   22,   68,    3,   68,   68,   68,   68,   68,
428
429       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
430       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
431       68,   68,   68
432    } ;
433
434static yyconst flex_int16_t yy_chk[124] =
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,    7,    7,
439        9,    9,   11,   11,   11,   15,   15,   15,   72,   11,
440       12,   12,   12,   12,   12,   13,   16,   16,   16,   13,
441       17,   12,   18,   12,   12,   21,   21,   21,   30,   23,
442       71,   23,   21,   23,   17,   17,   17,   30,   18,   18,
443       18,   22,   22,   45,   45,   45,   70,   22,   69,   56,
444       55,   54,   51,   50,   41,   34,   33,   28,   27,   25,
445       20,   14,   10,    3,   68,   68,   68,   68,   68,   68,
446
447       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
448       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
449       68,   68,   68
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 >= 69 )
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 != 68 );
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_FLUSH; }
688        YY_BREAK
689case 2:
690YY_RULE_SETUP
691#line 46 "mesh-scanner.l"
692{ return token::T_INITRB; }
693        YY_BREAK
694case 3:
695YY_RULE_SETUP
696#line 47 "mesh-scanner.l"
697{ return token::T_FREERB; }
698        YY_BREAK
699case 4:
700YY_RULE_SETUP
701#line 49 "mesh-scanner.l"
702{ return token::T_COLOR; }
703        YY_BREAK
704case 5:
705YY_RULE_SETUP
706#line 50 "mesh-scanner.l"
707{ return token::T_BGCOLOR; }
708        YY_BREAK
709case 6:
710YY_RULE_SETUP
711#line 52 "mesh-scanner.l"
712{ return token::T_TRANSLATEX; }
713        YY_BREAK
714case 7:
715YY_RULE_SETUP
716#line 53 "mesh-scanner.l"
717{ return token::T_TRANSLATEY; }
718        YY_BREAK
719case 8:
720YY_RULE_SETUP
721#line 54 "mesh-scanner.l"
722{ return token::T_TRANSLATEZ; }
723        YY_BREAK
724case 9:
725YY_RULE_SETUP
726#line 55 "mesh-scanner.l"
727{ return token::T_TRANSLATE; }
728        YY_BREAK
729case 10:
730YY_RULE_SETUP
731#line 56 "mesh-scanner.l"
732{ return token::T_ROTATEX; }
733        YY_BREAK
734case 11:
735YY_RULE_SETUP
736#line 57 "mesh-scanner.l"
737{ return token::T_ROTATEY; }
738        YY_BREAK
739case 12:
740YY_RULE_SETUP
741#line 58 "mesh-scanner.l"
742{ return token::T_ROTATEZ; }
743        YY_BREAK
744case 13:
745YY_RULE_SETUP
746#line 59 "mesh-scanner.l"
747{ return token::T_TAPERX; }
748        YY_BREAK
749case 14:
750YY_RULE_SETUP
751#line 60 "mesh-scanner.l"
752{ return token::T_TAPERY; }
753        YY_BREAK
754case 15:
755YY_RULE_SETUP
756#line 61 "mesh-scanner.l"
757{ return token::T_TAPERZ; }
758        YY_BREAK
759case 16:
760YY_RULE_SETUP
761#line 62 "mesh-scanner.l"
762{ return token::T_SCALEX; }
763        YY_BREAK
764case 17:
765YY_RULE_SETUP
766#line 63 "mesh-scanner.l"
767{ return token::T_SCALEY; }
768        YY_BREAK
769case 18:
770YY_RULE_SETUP
771#line 64 "mesh-scanner.l"
772{ return token::T_SCALEZ; }
773        YY_BREAK
774case 19:
775YY_RULE_SETUP
776#line 65 "mesh-scanner.l"
777{ return token::T_SCALE; }
778        YY_BREAK
779case 20:
780YY_RULE_SETUP
781#line 66 "mesh-scanner.l"
782{ return token::T_MIRRORX; }
783        YY_BREAK
784case 21:
785YY_RULE_SETUP
786#line 67 "mesh-scanner.l"
787{ return token::T_MIRRORY; }
788        YY_BREAK
789case 22:
790YY_RULE_SETUP
791#line 68 "mesh-scanner.l"
792{ return token::T_MIRRORZ; }
793        YY_BREAK
794case 23:
795YY_RULE_SETUP
796#line 70 "mesh-scanner.l"
797{ return token::T_CYLINDER; }
798        YY_BREAK
799case 24:
800YY_RULE_SETUP
801#line 71 "mesh-scanner.l"
802{ return token::T_BOX; }
803        YY_BREAK
804case 25:
805YY_RULE_SETUP
806#line 72 "mesh-scanner.l"
807{ return token::T_SMOOTHCHAMFBOX; }
808        YY_BREAK
809case 26:
810YY_RULE_SETUP
811#line 73 "mesh-scanner.l"
812{ return token::T_FLATCHAMFBOX; }
813        YY_BREAK
814case 27:
815YY_RULE_SETUP
816#line 74 "mesh-scanner.l"
817{ return token::T_SPHERE; }
818        YY_BREAK
819case 28:
820YY_RULE_SETUP
821#line 75 "mesh-scanner.l"
822{ return token::T_STAR; }
823        YY_BREAK
824case 29:
825YY_RULE_SETUP
826#line 76 "mesh-scanner.l"
827{ return token::T_EXPANDEDSTAR; }
828        YY_BREAK
829case 30:
830YY_RULE_SETUP
831#line 77 "mesh-scanner.l"
832{ return token::T_DISC; }
833        YY_BREAK
834case 31:
835YY_RULE_SETUP
836#line 78 "mesh-scanner.l"
837{ return token::T_TRIANGLE; }
838        YY_BREAK
839case 32:
840YY_RULE_SETUP
841#line 79 "mesh-scanner.l"
842{ return token::T_QUAD; }
843        YY_BREAK
844case 33:
845YY_RULE_SETUP
846#line 80 "mesh-scanner.l"
847{ return token::T_COG; }
848        YY_BREAK
849case 34:
850YY_RULE_SETUP
851#line 82 "mesh-scanner.l"
852{
853        char buf[] = "0x____";
854        sprintf(buf + 2, "%s", yytext + 1);
855        yylval->fval = atof(buf);
856        return token::COLOR;
857      }
858        YY_BREAK
859case 35:
860YY_RULE_SETUP
861#line 88 "mesh-scanner.l"
862{
863        yylval->fval = atof(yytext); return token::NUMBER; }
864        YY_BREAK
865case 36:
866YY_RULE_SETUP
867#line 90 "mesh-scanner.l"
868{ return token_type('-'); }
869        YY_BREAK
870case 37:
871YY_RULE_SETUP
872#line 91 "mesh-scanner.l"
873{ return token_type(','); }
874        YY_BREAK
875case 38:
876/* rule 38 can match eol */
877YY_RULE_SETUP
878#line 92 "mesh-scanner.l"
879{ /* ignore everything else */ }
880        YY_BREAK
881case 39:
882YY_RULE_SETUP
883#line 94 "mesh-scanner.l"
884ECHO;
885        YY_BREAK
886#line 887 "generated/mesh-scanner.cpp"
887case YY_STATE_EOF(INITIAL):
888        yyterminate();
889
890        case YY_END_OF_BUFFER:
891                {
892                /* Amount of text matched not including the EOB char. */
893                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
894
895                /* Undo the effects of YY_DO_BEFORE_ACTION. */
896                *yy_cp = (yy_hold_char);
897                YY_RESTORE_YY_MORE_OFFSET
898
899                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
900                        {
901                        /* We're scanning a new file or input source.  It's
902                         * possible that this happened because the user
903                         * just pointed yyin at a new source and called
904                         * yylex().  If so, then we have to assure
905                         * consistency between YY_CURRENT_BUFFER and our
906                         * globals.  Here is the right place to do so, because
907                         * this is the first action (other than possibly a
908                         * back-up) that will match for the new input source.
909                         */
910                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
911                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
912                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
913                        }
914
915                /* Note that here we test for yy_c_buf_p "<=" to the position
916                 * of the first EOB in the buffer, since yy_c_buf_p will
917                 * already have been incremented past the NUL character
918                 * (since all states make transitions on EOB to the
919                 * end-of-buffer state).  Contrast this with the test
920                 * in input().
921                 */
922                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
923                        { /* This was really a NUL. */
924                        yy_state_type yy_next_state;
925
926                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
927
928                        yy_current_state = yy_get_previous_state(  );
929
930                        /* Okay, we're now positioned to make the NUL
931                         * transition.  We couldn't have
932                         * yy_get_previous_state() go ahead and do it
933                         * for us because it doesn't know how to deal
934                         * with the possibility of jamming (and we don't
935                         * want to build jamming into it because then it
936                         * will run more slowly).
937                         */
938
939                        yy_next_state = yy_try_NUL_trans( yy_current_state );
940
941                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
942
943                        if ( yy_next_state )
944                                {
945                                /* Consume the NUL. */
946                                yy_cp = ++(yy_c_buf_p);
947                                yy_current_state = yy_next_state;
948                                goto yy_match;
949                                }
950
951                        else
952                                {
953                                yy_cp = (yy_last_accepting_cpos);
954                                yy_current_state = (yy_last_accepting_state);
955                                goto yy_find_action;
956                                }
957                        }
958
959                else switch ( yy_get_next_buffer(  ) )
960                        {
961                        case EOB_ACT_END_OF_FILE:
962                                {
963                                (yy_did_buffer_switch_on_eof) = 0;
964
965                                if ( yywrap(  ) )
966                                        {
967                                        /* Note: because we've taken care in
968                                         * yy_get_next_buffer() to have set up
969                                         * yytext, we can now set up
970                                         * yy_c_buf_p so that if some total
971                                         * hoser (like flex itself) wants to
972                                         * call the scanner after we return the
973                                         * YY_NULL, it'll still work - another
974                                         * YY_NULL will get returned.
975                                         */
976                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
977
978                                        yy_act = YY_STATE_EOF(YY_START);
979                                        goto do_action;
980                                        }
981
982                                else
983                                        {
984                                        if ( ! (yy_did_buffer_switch_on_eof) )
985                                                YY_NEW_FILE;
986                                        }
987                                break;
988                                }
989
990                        case EOB_ACT_CONTINUE_SCAN:
991                                (yy_c_buf_p) =
992                                        (yytext_ptr) + yy_amount_of_matched_text;
993
994                                yy_current_state = yy_get_previous_state(  );
995
996                                yy_cp = (yy_c_buf_p);
997                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
998                                goto yy_match;
999
1000                        case EOB_ACT_LAST_MATCH:
1001                                (yy_c_buf_p) =
1002                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1003
1004                                yy_current_state = yy_get_previous_state(  );
1005
1006                                yy_cp = (yy_c_buf_p);
1007                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1008                                goto yy_find_action;
1009                        }
1010                break;
1011                }
1012
1013        default:
1014                YY_FATAL_ERROR(
1015                        "fatal flex scanner internal error--no action found" );
1016        } /* end of action switch */
1017                } /* end of scanning one token */
1018} /* end of yylex */
1019
1020/* The contents of this function are C++ specific, so the () macro is not used.
1021 */
1022yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1023{
1024        yyin = arg_yyin;
1025        yyout = arg_yyout;
1026        yy_c_buf_p = 0;
1027        yy_init = 0;
1028        yy_start = 0;
1029        yy_flex_debug = 0;
1030        yylineno = 1;   // this will only get updated if %option yylineno
1031
1032        yy_did_buffer_switch_on_eof = 0;
1033
1034        yy_looking_for_trail_begin = 0;
1035        yy_more_flag = 0;
1036        yy_more_len = 0;
1037        yy_more_offset = yy_prev_more_offset = 0;
1038
1039        yy_start_stack_ptr = yy_start_stack_depth = 0;
1040        yy_start_stack = NULL;
1041
1042        yy_buffer_stack = 0;
1043        yy_buffer_stack_top = 0;
1044        yy_buffer_stack_max = 0;
1045
1046        yy_state_buf = 0;
1047
1048}
1049
1050/* The contents of this function are C++ specific, so the () macro is not used.
1051 */
1052yyFlexLexer::~yyFlexLexer()
1053{
1054        delete [] yy_state_buf;
1055        Meshfree(yy_start_stack  );
1056        yy_delete_buffer( YY_CURRENT_BUFFER );
1057        Meshfree(yy_buffer_stack  );
1058}
1059
1060/* The contents of this function are C++ specific, so the () macro is not used.
1061 */
1062void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1063{
1064        if ( new_in )
1065                {
1066                yy_delete_buffer( YY_CURRENT_BUFFER );
1067                yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  ) );
1068                }
1069
1070        if ( new_out )
1071                yyout = new_out;
1072}
1073
1074#ifdef YY_INTERACTIVE
1075int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
1076#else
1077int yyFlexLexer::LexerInput( char* buf, int max_size )
1078#endif
1079{
1080        if ( yyin->eof() || yyin->fail() )
1081                return 0;
1082
1083#ifdef YY_INTERACTIVE
1084        yyin->get( buf[0] );
1085
1086        if ( yyin->eof() )
1087                return 0;
1088
1089        if ( yyin->bad() )
1090                return -1;
1091
1092        return 1;
1093
1094#else
1095        (void) yyin->read( buf, max_size );
1096
1097        if ( yyin->bad() )
1098                return -1;
1099        else
1100                return yyin->gcount();
1101#endif
1102}
1103
1104void yyFlexLexer::LexerOutput( const char* buf, int size )
1105{
1106        (void) yyout->write( buf, size );
1107}
1108
1109/* yy_get_next_buffer - try to read in a new buffer
1110 *
1111 * Returns a code representing an action:
1112 *      EOB_ACT_LAST_MATCH -
1113 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1114 *      EOB_ACT_END_OF_FILE - end of file
1115 */
1116int yyFlexLexer::yy_get_next_buffer()
1117{
1118        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1119        register char *source = (yytext_ptr);
1120        register int number_to_move, i;
1121        int ret_val;
1122
1123        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1124                YY_FATAL_ERROR(
1125                "fatal flex scanner internal error--end of buffer missed" );
1126
1127        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1128                { /* Don't try to fill the buffer, so this is an EOF. */
1129                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1130                        {
1131                        /* We matched a single character, the EOB, so
1132                         * treat this as a final EOF.
1133                         */
1134                        return EOB_ACT_END_OF_FILE;
1135                        }
1136
1137                else
1138                        {
1139                        /* We matched some text prior to the EOB, first
1140                         * process it.
1141                         */
1142                        return EOB_ACT_LAST_MATCH;
1143                        }
1144                }
1145
1146        /* Try to read more data. */
1147
1148        /* First move last chars to start of buffer. */
1149        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1150
1151        for ( i = 0; i < number_to_move; ++i )
1152                *(dest++) = *(source++);
1153
1154        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1155                /* don't do the read, it's not guaranteed to return an EOF,
1156                 * just force an EOF
1157                 */
1158                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1159
1160        else
1161                {
1162                        int num_to_read =
1163                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1164
1165                while ( num_to_read <= 0 )
1166                        { /* Not enough room in the buffer - grow it. */
1167
1168                        /* just a shorter name for the current buffer */
1169                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1170
1171                        int yy_c_buf_p_offset =
1172                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1173
1174                        if ( b->yy_is_our_buffer )
1175                                {
1176                                int new_size = b->yy_buf_size * 2;
1177
1178                                if ( new_size <= 0 )
1179                                        b->yy_buf_size += b->yy_buf_size / 8;
1180                                else
1181                                        b->yy_buf_size *= 2;
1182
1183                                b->yy_ch_buf = (char *)
1184                                        /* Include room in for 2 EOB chars. */
1185                                        Meshrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1186                                }
1187                        else
1188                                /* Can't grow it, we don't own it. */
1189                                b->yy_ch_buf = 0;
1190
1191                        if ( ! b->yy_ch_buf )
1192                                YY_FATAL_ERROR(
1193                                "fatal error - scanner input buffer overflow" );
1194
1195                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1196
1197                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1198                                                number_to_move - 1;
1199
1200                        }
1201
1202                if ( num_to_read > YY_READ_BUF_SIZE )
1203                        num_to_read = YY_READ_BUF_SIZE;
1204
1205                /* Read in more data. */
1206                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1207                        (yy_n_chars), (size_t) num_to_read );
1208
1209                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1210                }
1211
1212        if ( (yy_n_chars) == 0 )
1213                {
1214                if ( number_to_move == YY_MORE_ADJ )
1215                        {
1216                        ret_val = EOB_ACT_END_OF_FILE;
1217                        yyrestart( yyin  );
1218                        }
1219
1220                else
1221                        {
1222                        ret_val = EOB_ACT_LAST_MATCH;
1223                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1224                                YY_BUFFER_EOF_PENDING;
1225                        }
1226                }
1227
1228        else
1229                ret_val = EOB_ACT_CONTINUE_SCAN;
1230
1231        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1232                /* Extend the array by 50%, plus the number we really need. */
1233                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1234                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) Meshrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1235                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1236                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1237        }
1238
1239        (yy_n_chars) += number_to_move;
1240        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1241        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1242
1243        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1244
1245        return ret_val;
1246}
1247
1248/* yy_get_previous_state - get the state just before the EOB char was reached */
1249
1250    yy_state_type yyFlexLexer::yy_get_previous_state()
1251{
1252        register yy_state_type yy_current_state;
1253        register char *yy_cp;
1254   
1255        yy_current_state = (yy_start);
1256
1257        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1258                {
1259                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1260                if ( yy_accept[yy_current_state] )
1261                        {
1262                        (yy_last_accepting_state) = yy_current_state;
1263                        (yy_last_accepting_cpos) = yy_cp;
1264                        }
1265                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1266                        {
1267                        yy_current_state = (int) yy_def[yy_current_state];
1268                        if ( yy_current_state >= 69 )
1269                                yy_c = yy_meta[(unsigned int) yy_c];
1270                        }
1271                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1272                }
1273
1274        return yy_current_state;
1275}
1276
1277/* yy_try_NUL_trans - try to make a transition on the NUL character
1278 *
1279 * synopsis
1280 *      next_state = yy_try_NUL_trans( current_state );
1281 */
1282    yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
1283{
1284        register int yy_is_jam;
1285        register char *yy_cp = (yy_c_buf_p);
1286
1287        register YY_CHAR yy_c = 1;
1288        if ( yy_accept[yy_current_state] )
1289                {
1290                (yy_last_accepting_state) = yy_current_state;
1291                (yy_last_accepting_cpos) = yy_cp;
1292                }
1293        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1294                {
1295                yy_current_state = (int) yy_def[yy_current_state];
1296                if ( yy_current_state >= 69 )
1297                        yy_c = yy_meta[(unsigned int) yy_c];
1298                }
1299        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1300        yy_is_jam = (yy_current_state == 68);
1301
1302        return yy_is_jam ? 0 : yy_current_state;
1303}
1304
1305    void yyFlexLexer::yyunput( int c, register char* yy_bp)
1306{
1307        register char *yy_cp;
1308   
1309    yy_cp = (yy_c_buf_p);
1310
1311        /* undo effects of setting up yytext */
1312        *yy_cp = (yy_hold_char);
1313
1314        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1315                { /* need to shift things up to make room */
1316                /* +2 for EOB chars. */
1317                register int number_to_move = (yy_n_chars) + 2;
1318                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1319                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1320                register char *source =
1321                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1322
1323                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1324                        *--dest = *--source;
1325
1326                yy_cp += (int) (dest - source);
1327                yy_bp += (int) (dest - source);
1328                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1329                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1330
1331                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1332                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1333                }
1334
1335        *--yy_cp = (char) c;
1336
1337        (yytext_ptr) = yy_bp;
1338        (yy_hold_char) = *yy_cp;
1339        (yy_c_buf_p) = yy_cp;
1340}
1341
1342    int yyFlexLexer::yyinput()
1343{
1344        int c;
1345   
1346        *(yy_c_buf_p) = (yy_hold_char);
1347
1348        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1349                {
1350                /* yy_c_buf_p now points to the character we want to return.
1351                 * If this occurs *before* the EOB characters, then it's a
1352                 * valid NUL; if not, then we've hit the end of the buffer.
1353                 */
1354                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1355                        /* This was really a NUL. */
1356                        *(yy_c_buf_p) = '\0';
1357
1358                else
1359                        { /* need more input */
1360                        int offset = (yy_c_buf_p) - (yytext_ptr);
1361                        ++(yy_c_buf_p);
1362
1363                        switch ( yy_get_next_buffer(  ) )
1364                                {
1365                                case EOB_ACT_LAST_MATCH:
1366                                        /* This happens because yy_g_n_b()
1367                                         * sees that we've accumulated a
1368                                         * token and flags that we need to
1369                                         * try matching the token before
1370                                         * proceeding.  But for input(),
1371                                         * there's no matching to consider.
1372                                         * So convert the EOB_ACT_LAST_MATCH
1373                                         * to EOB_ACT_END_OF_FILE.
1374                                         */
1375
1376                                        /* Reset buffer status. */
1377                                        yyrestart( yyin );
1378
1379                                        /*FALLTHROUGH*/
1380
1381                                case EOB_ACT_END_OF_FILE:
1382                                        {
1383                                        if ( yywrap(  ) )
1384                                                return EOF;
1385
1386                                        if ( ! (yy_did_buffer_switch_on_eof) )
1387                                                YY_NEW_FILE;
1388#ifdef __cplusplus
1389                                        return yyinput();
1390#else
1391                                        return input();
1392#endif
1393                                        }
1394
1395                                case EOB_ACT_CONTINUE_SCAN:
1396                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1397                                        break;
1398                                }
1399                        }
1400                }
1401
1402        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1403        *(yy_c_buf_p) = '\0';   /* preserve yytext */
1404        (yy_hold_char) = *++(yy_c_buf_p);
1405
1406        return c;
1407}
1408
1409/** Immediately switch to a different input stream.
1410 * @param input_file A readable stream.
1411 *
1412 * @note This function does not reset the start condition to @c INITIAL .
1413 */
1414    void yyFlexLexer::yyrestart( std::istream* input_file )
1415{
1416   
1417        if ( ! YY_CURRENT_BUFFER ){
1418        yyensure_buffer_stack ();
1419                YY_CURRENT_BUFFER_LVALUE =
1420            yy_create_buffer( yyin, YY_BUF_SIZE );
1421        }
1422
1423        yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1424        yy_load_buffer_state(  );
1425}
1426
1427/** Switch to a different input buffer.
1428 * @param new_buffer The new input buffer.
1429 *
1430 */
1431    void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1432{
1433   
1434        /* TODO. We should be able to replace this entire function body
1435         * with
1436         *              yypop_buffer_state();
1437         *              yypush_buffer_state(new_buffer);
1438     */
1439        yyensure_buffer_stack ();
1440        if ( YY_CURRENT_BUFFER == new_buffer )
1441                return;
1442
1443        if ( YY_CURRENT_BUFFER )
1444                {
1445                /* Flush out information for old buffer. */
1446                *(yy_c_buf_p) = (yy_hold_char);
1447                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1448                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1449                }
1450
1451        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1452        yy_load_buffer_state(  );
1453
1454        /* We don't actually know whether we did this switch during
1455         * EOF (yywrap()) processing, but the only time this flag
1456         * is looked at is after yywrap() is called, so it's safe
1457         * to go ahead and always set it.
1458         */
1459        (yy_did_buffer_switch_on_eof) = 1;
1460}
1461
1462    void yyFlexLexer::yy_load_buffer_state()
1463{
1464        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1465        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1466        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1467        (yy_hold_char) = *(yy_c_buf_p);
1468}
1469
1470/** Allocate and initialize an input buffer state.
1471 * @param file A readable stream.
1472 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1473 *
1474 * @return the allocated buffer state.
1475 */
1476    YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
1477{
1478        YY_BUFFER_STATE b;
1479   
1480        b = (YY_BUFFER_STATE) Meshalloc(sizeof( struct yy_buffer_state )  );
1481        if ( ! b )
1482                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1483
1484        b->yy_buf_size = size;
1485
1486        /* yy_ch_buf has to be 2 characters longer than the size given because
1487         * we need to put in 2 end-of-buffer characters.
1488         */
1489        b->yy_ch_buf = (char *) Meshalloc(b->yy_buf_size + 2  );
1490        if ( ! b->yy_ch_buf )
1491                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1492
1493        b->yy_is_our_buffer = 1;
1494
1495        yy_init_buffer( b, file );
1496
1497        return b;
1498}
1499
1500/** Destroy the buffer.
1501 * @param b a buffer created with yy_create_buffer()
1502 *
1503 */
1504    void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
1505{
1506   
1507        if ( ! b )
1508                return;
1509
1510        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1511                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1512
1513        if ( b->yy_is_our_buffer )
1514                Meshfree((void *) b->yy_ch_buf  );
1515
1516        Meshfree((void *) b  );
1517}
1518
1519extern "C" int isatty (int );
1520
1521/* Initializes or reinitializes a buffer.
1522 * This function is sometimes called more than once on the same buffer,
1523 * such as during a yyrestart() or at EOF.
1524 */
1525    void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
1526
1527{
1528        int oerrno = errno;
1529   
1530        yy_flush_buffer( b );
1531
1532        b->yy_input_file = file;
1533        b->yy_fill_buffer = 1;
1534
1535    /* If b is the current buffer, then yy_init_buffer was _probably_
1536     * called from yyrestart() or through yy_get_next_buffer.
1537     * In that case, we don't want to reset the lineno or column.
1538     */
1539    if (b != YY_CURRENT_BUFFER){
1540        b->yy_bs_lineno = 1;
1541        b->yy_bs_column = 0;
1542    }
1543
1544        b->yy_is_interactive = 0;
1545        errno = oerrno;
1546}
1547
1548/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1549 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1550 *
1551 */
1552    void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
1553{
1554        if ( ! b )
1555                return;
1556
1557        b->yy_n_chars = 0;
1558
1559        /* We always need two end-of-buffer characters.  The first causes
1560         * a transition to the end-of-buffer state.  The second causes
1561         * a jam in that state.
1562         */
1563        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1564        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1565
1566        b->yy_buf_pos = &b->yy_ch_buf[0];
1567
1568        b->yy_at_bol = 1;
1569        b->yy_buffer_status = YY_BUFFER_NEW;
1570
1571        if ( b == YY_CURRENT_BUFFER )
1572                yy_load_buffer_state(  );
1573}
1574
1575/** Pushes the new state onto the stack. The new state becomes
1576 *  the current state. This function will allocate the stack
1577 *  if necessary.
1578 *  @param new_buffer The new state.
1579 * 
1580 */
1581void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
1582{
1583        if (new_buffer == NULL)
1584                return;
1585
1586        yyensure_buffer_stack();
1587
1588        /* This block is copied from yy_switch_to_buffer. */
1589        if ( YY_CURRENT_BUFFER )
1590                {
1591                /* Flush out information for old buffer. */
1592                *(yy_c_buf_p) = (yy_hold_char);
1593                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1594                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1595                }
1596
1597        /* Only push if top exists. Otherwise, replace top. */
1598        if (YY_CURRENT_BUFFER)
1599                (yy_buffer_stack_top)++;
1600        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1601
1602        /* copied from yy_switch_to_buffer. */
1603        yy_load_buffer_state(  );
1604        (yy_did_buffer_switch_on_eof) = 1;
1605}
1606
1607/** Removes and deletes the top of the stack, if present.
1608 *  The next element becomes the new top.
1609 * 
1610 */
1611void yyFlexLexer::yypop_buffer_state (void)
1612{
1613        if (!YY_CURRENT_BUFFER)
1614                return;
1615
1616        yy_delete_buffer(YY_CURRENT_BUFFER );
1617        YY_CURRENT_BUFFER_LVALUE = NULL;
1618        if ((yy_buffer_stack_top) > 0)
1619                --(yy_buffer_stack_top);
1620
1621        if (YY_CURRENT_BUFFER) {
1622                yy_load_buffer_state(  );
1623                (yy_did_buffer_switch_on_eof) = 1;
1624        }
1625}
1626
1627/* Allocates the stack if it does not exist.
1628 *  Guarantees space for at least one push.
1629 */
1630void yyFlexLexer::yyensure_buffer_stack(void)
1631{
1632        int num_to_alloc;
1633   
1634        if (!(yy_buffer_stack)) {
1635
1636                /* First allocation is just for 2 elements, since we don't know if this
1637                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1638                 * immediate realloc on the next call.
1639         */
1640                num_to_alloc = 1;
1641                (yy_buffer_stack) = (struct yy_buffer_state**)Meshalloc
1642                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
1643                                                                );
1644                if ( ! (yy_buffer_stack) )
1645                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1646                                                                 
1647                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1648                               
1649                (yy_buffer_stack_max) = num_to_alloc;
1650                (yy_buffer_stack_top) = 0;
1651                return;
1652        }
1653
1654        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1655
1656                /* Increase the buffer to prepare for a possible push. */
1657                int grow_size = 8 /* arbitrary grow size */;
1658
1659                num_to_alloc = (yy_buffer_stack_max) + grow_size;
1660                (yy_buffer_stack) = (struct yy_buffer_state**)Meshrealloc
1661                                                                ((yy_buffer_stack),
1662                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
1663                                                                );
1664                if ( ! (yy_buffer_stack) )
1665                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1666
1667                /* zero only the new slots.*/
1668                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1669                (yy_buffer_stack_max) = num_to_alloc;
1670        }
1671}
1672
1673    void yyFlexLexer::yy_push_state( int new_state )
1674{
1675        if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
1676                {
1677                yy_size_t new_size;
1678
1679                (yy_start_stack_depth) += YY_START_STACK_INCR;
1680                new_size = (yy_start_stack_depth) * sizeof( int );
1681
1682                if ( ! (yy_start_stack) )
1683                        (yy_start_stack) = (int *) Meshalloc(new_size  );
1684
1685                else
1686                        (yy_start_stack) = (int *) Meshrealloc((void *) (yy_start_stack),new_size  );
1687
1688                if ( ! (yy_start_stack) )
1689                        YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
1690                }
1691
1692        (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
1693
1694        BEGIN(new_state);
1695}
1696
1697    void yyFlexLexer::yy_pop_state()
1698{
1699        if ( --(yy_start_stack_ptr) < 0 )
1700                YY_FATAL_ERROR( "start-condition stack underflow" );
1701
1702        BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
1703}
1704
1705    int yyFlexLexer::yy_top_state()
1706{
1707        return (yy_start_stack)[(yy_start_stack_ptr) - 1];
1708}
1709
1710#ifndef YY_EXIT_FAILURE
1711#define YY_EXIT_FAILURE 2
1712#endif
1713
1714void yyFlexLexer::LexerError( yyconst char msg[] )
1715{
1716        std::cerr << msg << std::endl;
1717        exit( YY_EXIT_FAILURE );
1718}
1719
1720/* Redefine yyless() so it works in section 3 code. */
1721
1722#undef yyless
1723#define yyless(n) \
1724        do \
1725                { \
1726                /* Undo effects of setting up yytext. */ \
1727        int yyless_macro_arg = (n); \
1728        YY_LESS_LINENO(yyless_macro_arg);\
1729                yytext[yyleng] = (yy_hold_char); \
1730                (yy_c_buf_p) = yytext + yyless_macro_arg; \
1731                (yy_hold_char) = *(yy_c_buf_p); \
1732                *(yy_c_buf_p) = '\0'; \
1733                yyleng = yyless_macro_arg; \
1734                } \
1735        while ( 0 )
1736
1737/* Accessor  methods (get/set functions) to struct members. */
1738
1739/*
1740 * Internal utility routines.
1741 */
1742
1743#ifndef yytext_ptr
1744static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1745{
1746        register int i;
1747        for ( i = 0; i < n; ++i )
1748                s1[i] = s2[i];
1749}
1750#endif
1751
1752#ifdef YY_NEED_STRLEN
1753static int yy_flex_strlen (yyconst char * s )
1754{
1755        register int n;
1756        for ( n = 0; s[n]; ++n )
1757                ;
1758
1759        return n;
1760}
1761#endif
1762
1763void *Meshalloc (yy_size_t  size )
1764{
1765        return (void *) malloc( size );
1766}
1767
1768void *Meshrealloc  (void * ptr, yy_size_t  size )
1769{
1770        /* The cast to (char *) in the following accommodates both
1771         * implementations that use char* generic pointers, and those
1772         * that use void* generic pointers.  It works with the latter
1773         * because both ANSI C and C++ allow castless assignment from
1774         * any pointer type to void*, and deal with argument conversions
1775         * as though doing an assignment.
1776         */
1777        return (void *) realloc( (char *) ptr, size );
1778}
1779
1780void Meshfree (void * ptr )
1781{
1782        free( (char *) ptr );   /* see Meshrealloc() for (char *) cast */
1783}
1784
1785#define YYTABLES_NAME "yytables"
1786
1787#line 94 "mesh-scanner.l"
1788
1789
1790
1791orbital::MeshScanner::MeshScanner(char const *command)
1792    : MeshFlexLexer(0, 0),
1793      m_input(command)
1794{
1795}
1796
1797orbital::MeshScanner::~MeshScanner()
1798{
1799}
1800
1801int orbital::MeshScanner::LexerInput(char* buf, int max_size)
1802{
1803    buf[0] = m_input[0];
1804    if (buf[0])
1805        ++m_input;
1806    return buf[0] ? 1 : 0;
1807}
1808
1809#ifdef yylex
1810#undef yylex
1811#endif
1812int MeshFlexLexer::yylex()
1813{
1814    std::cerr << "in MeshFlexLexer::yylex() !" << std::endl;
1815    return 0;
1816}
1817
1818int MeshFlexLexer::yywrap()
1819{
1820    return 1;
1821}
1822
1823
Note: See TracBrowser for help on using the repository browser.