source: trunk/src/generated/easymesh-scanner.cpp @ 1910

Last change on this file since 1910 was 1910, checked in by sam, 7 years ago

easymesh: use "ato" for torus, because "at" is already for triangle.

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