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

Last change on this file since 2226 was 2226, checked in by touky, 7 years ago

Added CSG v0.001a : not optimized, too much operation makes it slow. triangle count is not optimized.
Useage : "...[.... csg*]" equals "current mesh -CSG- the mesh in the braces".
Keywords : CsgUnion<csgu>, CsgSubstract<csgs>, CsgAnd<csga>, CsgXor<csgx>
TODO : cleanup useless code.
TODO : Some bugs are still present, some face that disappear should not.
TODO : Correct epsilon useage (see geometry files).
TODO : Coplanar face are not handled -at all-.
TODO : Vertex count goes through the roof in case of a Xor.

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