arith_lex.c@ 1433

Last change on this file since 1433 was 631, checked in by bird, 18 years ago
Checked in the generated source code.
File size: 41.2 KB

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

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

source: kBuild/trunk/src/ash/generated/arith_lex.c@ 1433

Download in other formats: