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

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

orbital: make sure to include "config.h" in all compiled files.

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