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

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

orbital: add "ch" command to create chamfers.

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