Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

conv_f8tof1_scanner.cpp @ 88

Last change on this file since 88 was 1, checked in by Maciej Komosinski, 16 years ago
added f8 (L-systems) representation and converter f8->f1
File size: 43.6 KB

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

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

Context Navigation

source: cpp/f8-to-f1/conv_f8tof1_scanner.cpp @ 88

Download in other formats: