WebSVN – HelenOS – Blame – /tags/0.3.0/uspace/app/ash/lex.yy.c

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

Subversion Repositories HelenOS

(root)/tags/0.3.0/uspace/app/ash/lex.yy.c – Rev 2781