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

Last change on this file since 1442 was 1442, checked in by sam, 8 years ago

orbital: some improvements to the mesh parser and error reporting.

  • Property svn:keywords set to Id
File size: 45.6 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 40
334#define YY_END_OF_BUFFER 41
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[64] =
343    {   0,
344        0,    0,   41,   39,   38,   37,   39,   39,   34,   39,
345       33,   35,   36,   39,   39,   39,   16,    6,    0,    0,
346       33,   33,    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,   33,   30,   26,
349        0,    0,    0,    2,   10,   11,   12,   31,   23,   22,
350       24,   32,    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[68] =
393    {   0,
394        0,    0,   89,   90,   90,   90,    0,   22,   24,   80,
395       26,   90,   90,   30,   10,   13,   34,   37,    0,   79,
396       50,   59,   45,   90,   68,   90,   61,   70,   90,   55,
397       90,   90,   90,   90,   90,   90,   90,   70,   90,   90,
398       90,   44,   90,   90,   90,    0,   74,   73,   90,   90,
399       67,   66,   59,   90,   90,   90,   90,    0,   90,   90,
400       90,   90,   90,   75,   72,   71,   54
401    } ;
402
403static yyconst flex_int16_t yy_def[68] =
404    {   0,
405       63,    1,   63,   63,   63,   63,   64,   63,   63,   63,
406       63,   63,   63,   63,   63,   63,   63,   63,   65,   63,
407       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
408       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
409       63,   63,   63,   63,   63,   66,   63,   63,   63,   63,
410       63,   63,   63,   63,   63,   63,   63,   67,   63,   63,
411       63,   63,    0,   63,   63,   63,   63
412    } ;
413
414static yyconst flex_int16_t yy_nxt[119] =
415    {   0,
416        4,    5,    6,    7,    8,    9,   10,   11,    4,   12,
417       13,   14,    4,    4,    4,    4,    4,    4,    4,   15,
418        4,    4,   16,   17,   18,    4,    4,    4,   20,   21,
419       20,   21,   20,   21,   23,   32,   33,   34,   35,   36,
420       37,   23,   24,   25,   26,   27,   28,   38,   42,   47,
421       47,   29,   48,   30,   31,   62,   20,   21,   23,   39,
422       40,   41,   43,   44,   45,   23,   22,   23,   52,   55,
423       56,   57,   58,   46,   23,   53,   19,   61,   60,   59,
424       48,   48,   54,   51,   50,   49,   22,   22,   63,    3,
425       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
426
427       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
428       63,   63,   63,   63,   63,   63,   63,   63
429    } ;
430
431static yyconst flex_int16_t yy_chk[119] =
432    {   0,
433        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
434        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
435        1,    1,    1,    1,    1,    1,    1,    1,    8,    8,
436        9,    9,   11,   11,   11,   15,   15,   15,   16,   16,
437       16,   11,   14,   14,   14,   14,   14,   17,   18,   23,
438       23,   14,   23,   14,   14,   67,   21,   21,   21,   17,
439       17,   17,   18,   18,   18,   21,   22,   22,   30,   42,
440       42,   42,   66,   65,   22,   30,   64,   53,   52,   51,
441       48,   47,   38,   28,   27,   25,   20,   10,    3,   63,
442       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
443
444       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
445       63,   63,   63,   63,   63,   63,   63,   63
446    } ;
447
448/* The intent behind this definition is that it'll catch
449 * any uses of REJECT which flex missed.
450 */
451#define REJECT reject_used_but_not_detected
452#define yymore() yymore_used_but_not_detected
453#define YY_MORE_ADJ 0
454#define YY_RESTORE_YY_MORE_OFFSET
455#line 1 "mesh-scanner.l"
456#line 2 "mesh-scanner.l"
457//
458// Orbital
459//
460// Copyright: (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
461//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
462//            (c) 2012 Sam Hocevar <sam@hocevar.net>
463//
464
465#if defined HAVE_CONFIG_H
466#   include "config.h"
467#endif
468
469#include "core.h"
470#include "loldebug.h"
471
472using namespace lol;
473
474#include "../mesh-compiler.h"
475
476typedef orbital::MeshParser::token token;
477typedef orbital::MeshParser::token_type token_type;
478
479#ifndef YY_DECL
480#   define YY_DECL orbital::MeshParser::token_type \
481        orbital::MeshScanner::lex(orbital::MeshParser::semantic_type* yylval, \
482                                  orbital::MeshParser::location_type* yylloc)
483#endif
484
485#define yyterminate() return token::T_END
486#define YY_NO_UNISTD_H
487#define YY_USER_ACTION yylloc->columns(yyleng);
488#line 489 "generated/mesh-scanner.cpp"
489
490#define INITIAL 0
491
492#ifndef YY_NO_UNISTD_H
493/* Special case for "unistd.h", since it is non-ANSI. We include it way
494 * down here because we want the user's section 1 to have been scanned first.
495 * The user has a chance to override it with an option.
496 */
497#include <unistd.h>
498#endif
499
500#ifndef YY_EXTRA_TYPE
501#define YY_EXTRA_TYPE void *
502#endif
503
504#ifndef yytext_ptr
505static void yy_flex_strncpy (char *,yyconst char *,int );
506#endif
507
508#ifdef YY_NEED_STRLEN
509static int yy_flex_strlen (yyconst char * );
510#endif
511
512#ifndef YY_NO_INPUT
513
514#endif
515
516/* Amount of stuff to slurp up with each read. */
517#ifndef YY_READ_BUF_SIZE
518#ifdef __ia64__
519/* On IA-64, the buffer size is 16k, not 8k */
520#define YY_READ_BUF_SIZE 16384
521#else
522#define YY_READ_BUF_SIZE 8192
523#endif /* __ia64__ */
524#endif
525
526/* Copy whatever the last rule matched to the standard output. */
527#ifndef ECHO
528#define ECHO LexerOutput( yytext, yyleng )
529#endif
530
531/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
532 * is returned in "result".
533 */
534#ifndef YY_INPUT
535#define YY_INPUT(buf,result,max_size) \
536\
537        if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
538                YY_FATAL_ERROR( "input in flex scanner failed" );
539
540#endif
541
542/* No semi-colon after return; correct usage is to write "yyterminate();" -
543 * we don't want an extra ';' after the "return" because that will cause
544 * some compilers to complain about unreachable statements.
545 */
546#ifndef yyterminate
547#define yyterminate() return YY_NULL
548#endif
549
550/* Number of entries by which start-condition stack grows. */
551#ifndef YY_START_STACK_INCR
552#define YY_START_STACK_INCR 25
553#endif
554
555/* Report a fatal error. */
556#ifndef YY_FATAL_ERROR
557#define YY_FATAL_ERROR(msg) LexerError( msg )
558#endif
559
560/* end tables serialization structures and prototypes */
561
562/* Default declaration of generated scanner - a define so the user can
563 * easily add parameters.
564 */
565#ifndef YY_DECL
566#define YY_DECL_IS_OURS 1
567#define YY_DECL int yyFlexLexer::yylex()
568#endif /* !YY_DECL */
569
570/* Code executed at the beginning of each rule, after yytext and yyleng
571 * have been set up.
572 */
573#ifndef YY_USER_ACTION
574#define YY_USER_ACTION
575#endif
576
577/* Code executed at the end of each rule. */
578#ifndef YY_BREAK
579#define YY_BREAK break;
580#endif
581
582#define YY_RULE_SETUP \
583        YY_USER_ACTION
584
585/** The main scanner function which does all the work.
586 */
587YY_DECL
588{
589        register yy_state_type yy_current_state;
590        register char *yy_cp, *yy_bp;
591        register int yy_act;
592   
593#line 38 "mesh-scanner.l"
594
595
596
597    /* reset location at the beginning of yylex() */
598    yylloc->step();
599
600
601#line 602 "generated/mesh-scanner.cpp"
602
603        if ( !(yy_init) )
604                {
605                (yy_init) = 1;
606
607#ifdef YY_USER_INIT
608                YY_USER_INIT;
609#endif
610
611                if ( ! (yy_start) )
612                        (yy_start) = 1; /* first start state */
613
614                if ( ! yyin )
615                        yyin = & std::cin;
616
617                if ( ! yyout )
618                        yyout = & std::cout;
619
620                if ( ! YY_CURRENT_BUFFER ) {
621                        yyensure_buffer_stack ();
622                        YY_CURRENT_BUFFER_LVALUE =
623                                yy_create_buffer( yyin, YY_BUF_SIZE );
624                }
625
626                yy_load_buffer_state(  );
627                }
628
629        while ( 1 )             /* loops until end-of-file is reached */
630                {
631                yy_cp = (yy_c_buf_p);
632
633                /* Support of yytext. */
634                *yy_cp = (yy_hold_char);
635
636                /* yy_bp points to the position in yy_ch_buf of the start of
637                 * the current run.
638                 */
639                yy_bp = yy_cp;
640
641                yy_current_state = (yy_start);
642yy_match:
643                do
644                        {
645                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
646                        if ( yy_accept[yy_current_state] )
647                                {
648                                (yy_last_accepting_state) = yy_current_state;
649                                (yy_last_accepting_cpos) = yy_cp;
650                                }
651                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
652                                {
653                                yy_current_state = (int) yy_def[yy_current_state];
654                                if ( yy_current_state >= 64 )
655                                        yy_c = yy_meta[(unsigned int) yy_c];
656                                }
657                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
658                        ++yy_cp;
659                        }
660                while ( yy_current_state != 63 );
661                yy_cp = (yy_last_accepting_cpos);
662                yy_current_state = (yy_last_accepting_state);
663
664yy_find_action:
665                yy_act = yy_accept[yy_current_state];
666
667                YY_DO_BEFORE_ACTION;
668
669do_action:      /* This label is used only to access EOF actions. */
670
671                switch ( yy_act )
672        { /* beginning of action switch */
673                        case 0: /* must back up */
674                        /* undo the effects of YY_DO_BEFORE_ACTION */
675                        *yy_cp = (yy_hold_char);
676                        yy_cp = (yy_last_accepting_cpos);
677                        yy_current_state = (yy_last_accepting_state);
678                        goto yy_find_action;
679
680case 1:
681YY_RULE_SETUP
682#line 45 "mesh-scanner.l"
683{ return token::T_COLOR; }
684        YY_BREAK
685case 2:
686YY_RULE_SETUP
687#line 46 "mesh-scanner.l"
688{ return token::T_BGCOLOR; }
689        YY_BREAK
690case 3:
691YY_RULE_SETUP
692#line 48 "mesh-scanner.l"
693{ return token::T_TRANSLATEX; }
694        YY_BREAK
695case 4:
696YY_RULE_SETUP
697#line 49 "mesh-scanner.l"
698{ return token::T_TRANSLATEY; }
699        YY_BREAK
700case 5:
701YY_RULE_SETUP
702#line 50 "mesh-scanner.l"
703{ return token::T_TRANSLATEZ; }
704        YY_BREAK
705case 6:
706YY_RULE_SETUP
707#line 51 "mesh-scanner.l"
708{ return token::T_TRANSLATE; }
709        YY_BREAK
710case 7:
711YY_RULE_SETUP
712#line 52 "mesh-scanner.l"
713{ return token::T_ROTATEX; }
714        YY_BREAK
715case 8:
716YY_RULE_SETUP
717#line 53 "mesh-scanner.l"
718{ return token::T_ROTATEY; }
719        YY_BREAK
720case 9:
721YY_RULE_SETUP
722#line 54 "mesh-scanner.l"
723{ return token::T_ROTATEZ; }
724        YY_BREAK
725case 10:
726YY_RULE_SETUP
727#line 55 "mesh-scanner.l"
728{ return token::T_TAPERX; }
729        YY_BREAK
730case 11:
731YY_RULE_SETUP
732#line 56 "mesh-scanner.l"
733{ return token::T_TAPERY; }
734        YY_BREAK
735case 12:
736YY_RULE_SETUP
737#line 57 "mesh-scanner.l"
738{ return token::T_TAPERZ; }
739        YY_BREAK
740case 13:
741YY_RULE_SETUP
742#line 58 "mesh-scanner.l"
743{ return token::T_SCALEX; }
744        YY_BREAK
745case 14:
746YY_RULE_SETUP
747#line 59 "mesh-scanner.l"
748{ return token::T_SCALEY; }
749        YY_BREAK
750case 15:
751YY_RULE_SETUP
752#line 60 "mesh-scanner.l"
753{ return token::T_SCALEZ; }
754        YY_BREAK
755case 16:
756YY_RULE_SETUP
757#line 61 "mesh-scanner.l"
758{ return token::T_SCALE; }
759        YY_BREAK
760case 17:
761YY_RULE_SETUP
762#line 62 "mesh-scanner.l"
763{ return token::T_MIRRORX; }
764        YY_BREAK
765case 18:
766YY_RULE_SETUP
767#line 63 "mesh-scanner.l"
768{ return token::T_MIRRORY; }
769        YY_BREAK
770case 19:
771YY_RULE_SETUP
772#line 64 "mesh-scanner.l"
773{ return token::T_MIRRORZ; }
774        YY_BREAK
775case 20:
776YY_RULE_SETUP
777#line 66 "mesh-scanner.l"
778{ return token::T_CYLINDER; }
779        YY_BREAK
780case 21:
781YY_RULE_SETUP
782#line 67 "mesh-scanner.l"
783{ return token::T_BOX; }
784        YY_BREAK
785case 22:
786YY_RULE_SETUP
787#line 68 "mesh-scanner.l"
788{ return token::T_SMOOTHCHAMFBOX; }
789        YY_BREAK
790case 23:
791YY_RULE_SETUP
792#line 69 "mesh-scanner.l"
793{ return token::T_FLATCHAMFBOX; }
794        YY_BREAK
795case 24:
796YY_RULE_SETUP
797#line 70 "mesh-scanner.l"
798{ return token::T_SPHERE; }
799        YY_BREAK
800case 25:
801YY_RULE_SETUP
802#line 71 "mesh-scanner.l"
803{ return token::T_STAR; }
804        YY_BREAK
805case 26:
806YY_RULE_SETUP
807#line 72 "mesh-scanner.l"
808{ return token::T_EXPANDEDSTAR; }
809        YY_BREAK
810case 27:
811YY_RULE_SETUP
812#line 73 "mesh-scanner.l"
813{ return token::T_DISC; }
814        YY_BREAK
815case 28:
816YY_RULE_SETUP
817#line 74 "mesh-scanner.l"
818{ return token::T_TRIANGLE; }
819        YY_BREAK
820case 29:
821YY_RULE_SETUP
822#line 75 "mesh-scanner.l"
823{ return token::T_QUAD; }
824        YY_BREAK
825case 30:
826YY_RULE_SETUP
827#line 76 "mesh-scanner.l"
828{ return token::T_COG; }
829        YY_BREAK
830case 31:
831YY_RULE_SETUP
832#line 78 "mesh-scanner.l"
833{
834        yylval->u32val = 0xf + 0x10 * strtol(yytext + 1, NULL, 16);
835        return token::COLOR; }
836        YY_BREAK
837case 32:
838YY_RULE_SETUP
839#line 81 "mesh-scanner.l"
840{
841        yylval->u32val = strtol(yytext + 1, NULL, 16);
842        return token::COLOR; }
843        YY_BREAK
844case 33:
845YY_RULE_SETUP
846#line 84 "mesh-scanner.l"
847{
848        yylval->fval = atof(yytext); return token::NUMBER; }
849        YY_BREAK
850case 34:
851YY_RULE_SETUP
852#line 86 "mesh-scanner.l"
853{ return token_type('-'); }
854        YY_BREAK
855case 35:
856YY_RULE_SETUP
857#line 87 "mesh-scanner.l"
858{ return token_type('['); }
859        YY_BREAK
860case 36:
861YY_RULE_SETUP
862#line 88 "mesh-scanner.l"
863{ return token_type(']'); }
864        YY_BREAK
865case 37:
866YY_RULE_SETUP
867#line 89 "mesh-scanner.l"
868{ /* ignore this */ }
869        YY_BREAK
870case 38:
871/* rule 38 can match eol */
872YY_RULE_SETUP
873#line 90 "mesh-scanner.l"
874{ /* ignore this */ }
875        YY_BREAK
876case 39:
877YY_RULE_SETUP
878#line 91 "mesh-scanner.l"
879{ return token::T_ERROR; }
880        YY_BREAK
881case 40:
882YY_RULE_SETUP
883#line 93 "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 >= 64 )
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 >= 64 )
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 == 63);
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 93 "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.