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

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

easymesh: add the capsule mesh.

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