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

Last change on this file since 2318 was 2318, checked in by sam, 8 years ago

build: fix all vector/scalar type mismatches such as "vec2 * double"
instead of "vec2 * float".

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