Context Navigation

source: trunk/orbital/generated/mesh-scanner.cpp @ 1434
Tweet

Last change on this file since 1434 was 1434, checked in by sam, 11 years ago
orbital: enhance the language with [] contexts.
Property svn:keywords set to `Id`
File size: 45.8 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: