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

Last change on this file since 1512 was 1512, checked in by sam, 10 years ago

build: fix the PS3 port by using our trig.h everywhere instead of stdlib
functions; also remove a lot of idiotic "using namespace std" from the
codebase.

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