Context Navigation

source: trunk/gsdl/src/recpt/parse.yy.c@ 1941

Last change on this file since 1941 was 1941, checked in by jmt14, 23 years ago

Modified files:

browsetools.cpp documentaction.cpp formattools.cpp
formattools.h

Property svn:keywords set to Author Date Id Revision

File size: 49.8 KB

Line
1	#line 2 "parse.yy.c"
2	/* A lexical scanner generated by flex */
3
4	/* Scanner skeleton version:
5	* $Header$
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
14
15	/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
16	#ifdef c_plusplus
17	#ifndef __cplusplus
18	#define __cplusplus
19	#endif
20	#endif
21
22
23	#ifdef __cplusplus
24
25	#include <stdlib.h>
26	#include <unistd.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 46
290	#define YY_END_OF_BUFFER 47
291	static yyconst short int yy_accept[274] =
292	{ 0,
293	0, 0, 38, 38, 47, 46, 44, 45, 37, 46,
294	2, 43, 3, 43, 43, 43, 43, 43, 43, 43,
295	43, 43, 46, 4, 43, 43, 43, 43, 43, 43,
296	43, 43, 38, 39, 42, 46, 0, 1, 1, 43,
297	43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
298	43, 43, 43, 43, 0, 0, 0, 0, 43, 43,
299	43, 43, 43, 43, 43, 38, 39, 0, 41, 40,
300	43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
301	43, 43, 43, 43, 43, 0, 0, 0, 0, 0,
302	43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
303
304	43, 43, 35, 43, 21, 23, 43, 43, 43, 43,
305	43, 29, 0, 0, 0, 0, 0, 43, 35, 43,
306	43, 31, 43, 43, 12, 43, 43, 43, 43, 43,
307	43, 43, 43, 43, 43, 43, 0, 0, 0, 0,
308	0, 32, 43, 43, 43, 43, 13, 43, 43, 22,
309	43, 43, 43, 43, 43, 43, 43, 0, 0, 0,
310	0, 0, 43, 30, 43, 43, 43, 43, 43, 43,
311	43, 43, 43, 43, 43, 43, 0, 0, 0, 0,
312	0, 43, 43, 34, 14, 43, 20, 43, 43, 43,
313	43, 43, 43, 28, 0, 0, 0, 9, 0, 43,
314
315	33, 43, 43, 43, 43, 43, 11, 43, 43, 36,
316	43, 43, 0, 5, 6, 0, 43, 43, 43, 43,
317	43, 43, 24, 43, 26, 43, 0, 0, 10, 43,
318	43, 43, 43, 43, 25, 43, 0, 0, 43, 43,
319	43, 43, 19, 43, 0, 0, 43, 43, 43, 43,
320	43, 0, 0, 43, 43, 17, 18, 43, 0, 0,
321	43, 16, 43, 8, 7, 43, 43, 43, 27, 43,
322	43, 15, 0
323	} ;
324
325	static yyconst int yy_ec[256] =
326	{ 0,
327	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
328	1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
329	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
330	1, 5, 1, 6, 7, 1, 1, 1, 1, 1,
331	1, 1, 1, 8, 9, 10, 1, 11, 11, 11,
332	11, 11, 11, 11, 11, 11, 11, 12, 1, 1,
333	1, 1, 1, 9, 13, 14, 9, 15, 9, 16,
334	17, 18, 19, 9, 9, 20, 21, 22, 9, 9,
335	9, 9, 23, 24, 9, 9, 9, 9, 9, 9,
336	25, 26, 27, 1, 28, 1, 29, 30, 31, 32,
337
338	33, 34, 35, 36, 37, 9, 38, 39, 40, 41,
339	42, 43, 9, 44, 45, 46, 47, 9, 48, 49,
340	50, 9, 1, 1, 1, 1, 1, 1, 1, 1,
341	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
342	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
343	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
344	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
345	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
346	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
347	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
348
349	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
351	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
352	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
353	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
354	1, 1, 1, 1, 1
355	} ;
356
357	static yyconst int yy_meta[51] =
358	{ 0,
359	1, 1, 1, 1, 1, 2, 1, 1, 3, 3,
360	3, 1, 3, 3, 3, 3, 3, 3, 3, 3,
361	3, 3, 3, 3, 1, 2, 1, 1, 3, 3,
362	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
363	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
364	} ;
365
366	static yyconst short int yy_base[279] =
367	{ 0,
368	0, 19, 49, 50, 331, 332, 332, 332, 332, 54,
369	332, 0, 332, 300, 285, 25, 286, 296, 31, 297,
370	29, 28, 49, 332, 296, 293, 294, 275, 281, 276,
371	277, 40, 315, 314, 310, 309, 78, 332, 80, 0,
372	272, 271, 266, 280, 266, 267, 267, 262, 266, 48,
373	276, 260, 254, 259, 257, 62, 271, 266, 259, 255,
374	259, 265, 247, 262, 261, 288, 287, 286, 332, 332,
375	241, 239, 253, 238, 244, 242, 247, 235, 247, 235,
376	232, 238, 230, 229, 241, 231, 257, 230, 239, 240,
377	223, 226, 225, 226, 231, 216, 216, 215, 215, 54,
378
379	219, 229, 66, 210, 0, 0, 225, 218, 215, 220,
380	67, 0, 204, 231, 217, 205, 204, 214, 0, 200,
381	208, 0, 204, 206, 0, 209, 204, 207, 193, 201,
382	208, 200, 193, 70, 202, 196, 187, 220, 186, 187,
383	197, 0, 198, 195, 192, 182, 0, 178, 181, 0,
384	180, 185, 64, 178, 187, 74, 176, 183, 80, 186,
385	169, 177, 175, 0, 170, 169, 163, 162, 169, 173,
386	172, 72, 162, 166, 169, 163, 195, 188, 159, 170,
387	191, 154, 148, 0, 0, 107, 0, 148, 143, 154,
388	149, 144, 157, 0, 80, 88, 160, 332, 82, 153,
389
390	0, 141, 137, 150, 142, 148, 0, 134, 134, 0,
391	132, 131, 139, 332, 332, 138, 130, 129, 126, 142,
392	141, 120, 0, 122, 0, 130, 133, 131, 0, 119,
393	106, 119, 115, 103, 0, 106, 108, 107, 97, 100,
394	108, 107, 0, 98, 106, 103, 89, 92, 88, 85,
395	83, 84, 83, 87, 82, 0, 0, 87, 96, 91,
396	70, 0, 64, 332, 332, 62, 58, 56, 0, 58,
397	25, 0, 332, 153, 156, 56, 159, 162
398	} ;
399
400	static yyconst short int yy_def[279] =
401	{ 0,
402	273, 1, 274, 274, 273, 273, 273, 273, 273, 275,
403	273, 276, 273, 276, 276, 276, 276, 276, 276, 276,
404	276, 276, 273, 273, 276, 276, 276, 276, 276, 276,
405	276, 276, 277, 278, 273, 273, 275, 273, 275, 276,
406	276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
407	276, 276, 276, 276, 273, 273, 273, 273, 276, 276,
408	276, 276, 276, 276, 276, 277, 278, 278, 273, 273,
409	276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
410	276, 276, 276, 276, 276, 273, 273, 273, 273, 273,
411	276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
412
413	276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
414	276, 276, 273, 273, 273, 273, 273, 276, 276, 276,
415	276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
416	276, 276, 276, 276, 276, 276, 273, 273, 273, 273,
417	273, 276, 276, 276, 276, 276, 276, 276, 276, 276,
418	276, 276, 276, 276, 276, 276, 276, 273, 273, 273,
419	273, 273, 276, 276, 276, 276, 276, 276, 276, 276,
420	276, 276, 276, 276, 276, 276, 273, 273, 273, 273,
421	273, 276, 276, 276, 276, 276, 276, 276, 276, 276,
422	276, 276, 276, 276, 273, 273, 273, 273, 273, 276,
423
424	276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
425	276, 276, 273, 273, 273, 273, 276, 276, 276, 276,
426	276, 276, 276, 276, 276, 276, 273, 273, 276, 276,
427	276, 276, 276, 276, 276, 276, 273, 273, 276, 276,
428	276, 276, 276, 276, 273, 273, 276, 276, 276, 276,
429	276, 273, 273, 276, 276, 276, 276, 276, 273, 273,
430	276, 276, 276, 273, 273, 276, 276, 276, 276, 276,
431	276, 276, 0, 273, 273, 273, 273, 273
432	} ;
433
434	static yyconst short int yy_nxt[383] =
435	{ 0,
436	6, 7, 8, 8, 7, 9, 10, 11, 12, 12,
437	12, 13, 14, 15, 16, 17, 12, 12, 18, 19,
438	12, 20, 21, 22, 23, 6, 6, 24, 12, 12,
439	12, 12, 12, 25, 12, 12, 26, 12, 12, 27,
440	12, 12, 28, 12, 29, 30, 12, 12, 12, 12,
441	31, 34, 34, 43, 35, 35, 38, 39, 40, 47,
442	53, 50, 55, 32, 272, 56, 44, 48, 51, 57,
443	52, 58, 65, 127, 36, 36, 80, 54, 81, 51,
444	38, 39, 38, 39, 87, 130, 136, 171, 155, 178,
445	159, 190, 127, 174, 88, 213, 175, 216, 196, 271,
446
447	261, 270, 258, 269, 130, 136, 155, 268, 267, 171,
448	190, 266, 174, 213, 214, 216, 261, 265, 175, 202,
449	203, 258, 264, 263, 204, 205, 262, 260, 259, 257,
450	206, 256, 255, 254, 253, 202, 203, 252, 251, 250,
451	249, 248, 204, 205, 247, 246, 245, 244, 243, 242,
452	241, 240, 206, 33, 33, 33, 37, 37, 37, 66,
453	239, 66, 68, 238, 68, 237, 236, 235, 234, 233,
454	232, 231, 230, 229, 228, 227, 226, 225, 224, 223,
455	222, 221, 220, 219, 218, 217, 215, 212, 211, 210,
456	209, 208, 207, 201, 200, 199, 198, 197, 196, 195,
457
458	194, 193, 192, 191, 189, 188, 187, 186, 185, 184,
459	183, 182, 181, 180, 179, 177, 176, 173, 172, 170,
460	169, 168, 167, 166, 165, 164, 163, 162, 161, 160,
461	159, 158, 157, 156, 154, 153, 152, 151, 150, 149,
462	148, 147, 146, 145, 144, 143, 142, 141, 140, 139,
463	138, 137, 135, 134, 133, 132, 131, 129, 128, 126,
464	125, 124, 123, 122, 121, 120, 119, 118, 117, 116,
465	115, 114, 113, 112, 111, 110, 109, 108, 107, 106,
466	105, 104, 103, 102, 101, 100, 99, 98, 67, 67,
467	67, 97, 96, 95, 94, 93, 92, 91, 90, 89,
468
469	86, 85, 84, 83, 82, 79, 78, 77, 76, 75,
470	74, 73, 72, 71, 70, 69, 67, 67, 64, 63,
471	51, 62, 61, 60, 59, 49, 46, 45, 42, 41,
472	273, 5, 273, 273, 273, 273, 273, 273, 273, 273,
473	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
474	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
475	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
476	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
477	273, 273
478	} ;
479
480	static yyconst short int yy_chk[383] =
481	{ 0,
482	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
483	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
484	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
485	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
486	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
487	2, 3, 4, 16, 3, 4, 10, 10, 276, 19,
488	22, 21, 23, 2, 271, 23, 16, 19, 21, 23,
489	21, 23, 32, 100, 3, 4, 50, 22, 50, 32,
490	37, 37, 39, 39, 56, 103, 111, 153, 134, 159,
491	159, 172, 100, 156, 56, 195, 156, 199, 196, 270,
492
493	254, 268, 251, 267, 103, 111, 134, 266, 263, 153,
494	172, 261, 156, 195, 196, 199, 254, 260, 156, 186,
495	186, 251, 259, 258, 186, 186, 255, 253, 252, 250,
496	186, 249, 248, 247, 246, 186, 186, 245, 244, 242,
497	241, 240, 186, 186, 239, 238, 237, 236, 234, 233,
498	232, 231, 186, 274, 274, 274, 275, 275, 275, 277,
499	230, 277, 278, 228, 278, 227, 226, 224, 222, 221,
500	220, 219, 218, 217, 216, 213, 212, 211, 209, 208,
501	206, 205, 204, 203, 202, 200, 197, 193, 192, 191,
502	190, 189, 188, 183, 182, 181, 180, 179, 178, 177,
503
504	176, 175, 174, 173, 171, 170, 169, 168, 167, 166,
505	165, 163, 162, 161, 160, 158, 157, 155, 154, 152,
506	151, 149, 148, 146, 145, 144, 143, 141, 140, 139,
507	138, 137, 136, 135, 133, 132, 131, 130, 129, 128,
508	127, 126, 124, 123, 121, 120, 118, 117, 116, 115,
509	114, 113, 110, 109, 108, 107, 104, 102, 101, 99,
510	98, 97, 96, 95, 94, 93, 92, 91, 90, 89,
511	88, 87, 86, 85, 84, 83, 82, 81, 80, 79,
512	78, 77, 76, 75, 74, 73, 72, 71, 68, 67,
513	66, 65, 64, 63, 62, 61, 60, 59, 58, 57,
514
515	55, 54, 53, 52, 51, 49, 48, 47, 46, 45,
516	44, 43, 42, 41, 36, 35, 34, 33, 31, 30,
517	29, 28, 27, 26, 25, 20, 18, 17, 15, 14,
518	5, 273, 273, 273, 273, 273, 273, 273, 273, 273,
519	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
520	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
521	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
522	273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
523	273, 273
524	} ;
525
526	static yy_state_type yy_last_accepting_state;
527	static char *yy_last_accepting_cpos;
528
529	/* The intent behind this definition is that it'll catch
530	* any uses of REJECT which flex missed.
531	*/
532	#define REJECT reject_used_but_not_detected
533	#define yymore() yymore_used_but_not_detected
534	#define YY_MORE_ADJ 0
535	#define YY_RESTORE_YY_MORE_OFFSET
536	char *yytext;
537	#line 1 "parse.fl"
538	#define INITIAL 0
539	/* This is the lexical analyser - it returns tokens to the parsers.
540	This is used by both parsers - one for the build-time config files
541	and one for the run-time config files. Note the included file "parse.h"
542	is a symlink to the relevant header file. */
543	#line 7 "parse.fl"
544	#include <string.h>
545	#include <stdlib.h>
546	#include <stdio.h>
547
548	/#define YYSTYPE char - YYSTYPE is defined in zparse.tab.h */
549	#include "zparse.tab.h"
550
551	/* forward declarations for std functions not picked up. */
552	/int fileno(FILE );*/
553	/char strdup(char );/
554
555	int lineno=1;
556	#define STRINGCOND 1
557
558	#line 559 "parse.yy.c"
559
560	/* Macros after this point can all be overridden by user definitions in
561	* section 1.
562	*/
563
564	#ifndef YY_SKIP_YYWRAP
565	#ifdef __cplusplus
566	extern "C" int yywrap YY_PROTO(( void ));
567	#else
568	extern int yywrap YY_PROTO(( void ));
569	#endif
570	#endif
571
572	#ifndef YY_NO_UNPUT
573	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
574	#endif
575
576	#ifndef yytext_ptr
577	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
578	#endif
579
580	#ifdef YY_NEED_STRLEN
581	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
582	#endif
583
584	#ifndef YY_NO_INPUT
585	#ifdef __cplusplus
586	static int yyinput YY_PROTO(( void ));
587	#else
588	static int input YY_PROTO(( void ));
589	#endif
590	#endif
591
592	#if YY_STACK_USED
593	static int yy_start_stack_ptr = 0;
594	static int yy_start_stack_depth = 0;
595	static int *yy_start_stack = 0;
596	#ifndef YY_NO_PUSH_STATE
597	static void yy_push_state YY_PROTO(( int new_state ));
598	#endif
599	#ifndef YY_NO_POP_STATE
600	static void yy_pop_state YY_PROTO(( void ));
601	#endif
602	#ifndef YY_NO_TOP_STATE
603	static int yy_top_state YY_PROTO(( void ));
604	#endif
605
606	#else
607	#define YY_NO_PUSH_STATE 1
608	#define YY_NO_POP_STATE 1
609	#define YY_NO_TOP_STATE 1
610	#endif
611
612	#ifdef YY_MALLOC_DECL
613	YY_MALLOC_DECL
614	#else
615	#if __STDC__
616	#ifndef __cplusplus
617	#include <stdlib.h>
618	#endif
619	#else
620	/* Just try to get by without declaring the routines. This will fail
621	* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
622	* or sizeof(void*) != sizeof(int).
623	*/
624	#endif
625	#endif
626
627	/* Amount of stuff to slurp up with each read. */
628	#ifndef YY_READ_BUF_SIZE
629	#define YY_READ_BUF_SIZE 8192
630	#endif
631
632	/* Copy whatever the last rule matched to the standard output. */
633
634	#ifndef ECHO
635	/* This used to be an fputs(), but since the string might contain NUL's,
636	* we now use fwrite().
637	*/
638	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
639	#endif
640
641	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
642	* is returned in "result".
643	*/
644	#ifndef YY_INPUT
645	#define YY_INPUT(buf,result,max_size) \
646	if ( yy_current_buffer->yy_is_interactive ) \
647	{ \
648	int c = '*', n; \
649	for ( n = 0; n < max_size && \
650	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
651	buf[n] = (char) c; \
652	if ( c == '\n' ) \
653	buf[n++] = (char) c; \
654	if ( c == EOF && ferror( yyin ) ) \
655	YY_FATAL_ERROR( "input in flex scanner failed" ); \
656	result = n; \
657	} \
658	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
659	&& ferror( yyin ) ) \
660	YY_FATAL_ERROR( "input in flex scanner failed" );
661	#endif
662
663	/* No semi-colon after return; correct usage is to write "yyterminate();" -
664	* we don't want an extra ';' after the "return" because that will cause
665	* some compilers to complain about unreachable statements.
666	*/
667	#ifndef yyterminate
668	#define yyterminate() return YY_NULL
669	#endif
670
671	/* Number of entries by which start-condition stack grows. */
672	#ifndef YY_START_STACK_INCR
673	#define YY_START_STACK_INCR 25
674	#endif
675
676	/* Report a fatal error. */
677	#ifndef YY_FATAL_ERROR
678	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
679	#endif
680
681	/* Default declaration of generated scanner - a define so the user can
682	* easily add parameters.
683	*/
684	#ifndef YY_DECL
685	#define YY_DECL int yylex YY_PROTO(( void ))
686	#endif
687
688	/* Code executed at the beginning of each rule, after yytext and yyleng
689	* have been set up.
690	*/
691	#ifndef YY_USER_ACTION
692	#define YY_USER_ACTION
693	#endif
694
695	/* Code executed at the end of each rule. */
696	#ifndef YY_BREAK
697	#define YY_BREAK break;
698	#endif
699
700	#define YY_RULE_SETUP \
701	if ( yyleng > 0 ) \
702	yy_current_buffer->yy_at_bol = \
703	(yytext[yyleng - 1] == '\n'); \
704	YY_USER_ACTION
705
706	YY_DECL
707	{
708	register yy_state_type yy_current_state;
709	register char yy_cp, yy_bp;
710	register int yy_act;
711
712	#line 26 "parse.fl"
713
714	char *string;
715	int string_len;
716
717	#line 718 "parse.yy.c"
718
719	if ( yy_init )
720	{
721	yy_init = 0;
722
723	#ifdef YY_USER_INIT
724	YY_USER_INIT;
725	#endif
726
727	if ( ! yy_start )
728	yy_start = 1; /* first start state */
729
730	if ( ! yyin )
731	yyin = stdin;
732
733	if ( ! yyout )
734	yyout = stdout;
735
736	if ( ! yy_current_buffer )
737	yy_current_buffer =
738	yy_create_buffer( yyin, YY_BUF_SIZE );
739
740	yy_load_buffer_state();
741	}
742
743	while ( 1 ) /* loops until end-of-file is reached */
744	{
745	yy_cp = yy_c_buf_p;
746
747	/* Support of yytext. */
748	*yy_cp = yy_hold_char;
749
750	/* yy_bp points to the position in yy_ch_buf of the start of
751	* the current run.
752	*/
753	yy_bp = yy_cp;
754
755	yy_current_state = yy_start;
756	yy_current_state += YY_AT_BOL();
757	yy_match:
758	do
759	{
760	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
761	if ( yy_accept[yy_current_state] )
762	{
763	yy_last_accepting_state = yy_current_state;
764	yy_last_accepting_cpos = yy_cp;
765	}
766	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
767	{
768	yy_current_state = (int) yy_def[yy_current_state];
769	if ( yy_current_state >= 274 )
770	yy_c = yy_meta[(unsigned int) yy_c];
771	}
772	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
773	++yy_cp;
774	}
775	while ( yy_base[yy_current_state] != 332 );
776
777	yy_find_action:
778	yy_act = yy_accept[yy_current_state];
779	if ( yy_act == 0 )
780	{ /* have to back up */
781	yy_cp = yy_last_accepting_cpos;
782	yy_current_state = yy_last_accepting_state;
783	yy_act = yy_accept[yy_current_state];
784	}
785
786	YY_DO_BEFORE_ACTION;
787
788
789	do_action: /* This label is used only to access EOF actions. */
790
791
792	switch ( yy_act )
793	{ /* beginning of action switch */
794	case 0: /* must back up */
795	/* undo the effects of YY_DO_BEFORE_ACTION */
796	*yy_cp = yy_hold_char;
797	yy_cp = yy_last_accepting_cpos;
798	yy_current_state = yy_last_accepting_state;
799	goto yy_find_action;
800
801	case 1:
802	YY_RULE_SETUP
803	#line 30 "parse.fl"
804	lineno++;/yylval.string=yytext;/yyleng=0;
805	YY_BREAK
806	case 2:
807	YY_RULE_SETUP
808	#line 31 "parse.fl"
809	return (',');
810	YY_BREAK
811	case 3:
812	YY_RULE_SETUP
813	#line 32 "parse.fl"
814	return (':');
815	YY_BREAK
816	case 4:
817	YY_RULE_SETUP
818	#line 33 "parse.fl"
819	return ('_');
820	YY_BREAK
821	case 5:
822	YY_RULE_SETUP
823	#line 34 "parse.fl"
824	yylval.string=yytext;return(GSDLVERSION);
825	YY_BREAK
826	case 6:
827	YY_RULE_SETUP
828	#line 35 "parse.fl"
829	return (GENERAL_SECTION);
830	YY_BREAK
831	case 7:
832	YY_RULE_SETUP
833	#line 36 "parse.fl"
834	return (SEARCH_SECTION);
835	YY_BREAK
836	case 8:
837	YY_RULE_SETUP
838	#line 37 "parse.fl"
839	return (BROWSE_SECTION);
840	YY_BREAK
841	case 9:
842	YY_RULE_SETUP
843	#line 38 "parse.fl"
844	return (MACROS_SECTION);
845	YY_BREAK
846	case 10:
847	YY_RULE_SETUP
848	#line 39 "parse.fl"
849	return (MAINTAINER);
850	YY_BREAK
851	case 11:
852	YY_RULE_SETUP
853	#line 40 "parse.fl"
854	return(LANGUAGES);
855	YY_BREAK
856	case 12:
857	YY_RULE_SETUP
858	#line 41 "parse.fl"
859	return(ABOUT);
860	YY_BREAK
861	case 13:
862	YY_RULE_SETUP
863	#line 42 "parse.fl"
864	return(BROWSE);
865	YY_BREAK
866	case 14:
867	YY_RULE_SETUP
868	#line 43 "parse.fl"
869	return(DATELIST);
870	YY_BREAK
871	case 15:
872	YY_RULE_SETUP
873	#line 44 "parse.fl"
874	return(DOCUMENTARROWSBOTTOM);
875	YY_BREAK
876	case 16:
877	YY_RULE_SETUP
878	#line 45 "parse.fl"
879	return(DOCUMENTBUTTONS);
880	YY_BREAK
881	case 17:
882	YY_RULE_SETUP
883	#line 46 "parse.fl"
884	return(DOCUMENTHEADER);
885	YY_BREAK
886	case 18:
887	YY_RULE_SETUP
888	#line 47 "parse.fl"
889	return(DOCUMENTIMAGES);
890	YY_BREAK
891	case 19:
892	YY_RULE_SETUP
893	#line 48 "parse.fl"
894	return(DOCUMENTTEXT);
895	YY_BREAK
896	case 20:
897	YY_RULE_SETUP
898	#line 49 "parse.fl"
899	return(ICONLINK);
900	YY_BREAK
901	case 21:
902	YY_RULE_SETUP
903	#line 50 "parse.fl"
904	return(LIST);
905	YY_BREAK
906	case 22:
907	YY_RULE_SETUP
908	#line 51 "parse.fl"
909	return(FORMAT);
910	YY_BREAK
911	case 23:
912	YY_RULE_SETUP
913	#line 52 "parse.fl"
914	return(NAME);
915	YY_BREAK
916	case 24:
917	YY_RULE_SETUP
918	#line 53 "parse.fl"
919	return(SEARCHTEXT);
920	YY_BREAK
921	case 25:
922	YY_RULE_SETUP
923	#line 54 "parse.fl"
924	return(SECTIONLIST);
925	YY_BREAK
926	case 26:
927	YY_RULE_SETUP
928	#line 55 "parse.fl"
929	return(SORTEDLIST);
930	YY_BREAK
931	case 27:
932	YY_RULE_SETUP
933	#line 56 "parse.fl"
934	return(SORTEDSECTIONLIST);
935	YY_BREAK
936	case 28:
937	YY_RULE_SETUP
938	#line 57 "parse.fl"
939	return(TEXTLINK);
940	YY_BREAK
941	case 29:
942	YY_RULE_SETUP
943	#line 58 "parse.fl"
944	return(TYPE);
945	YY_BREAK
946	case 30:
947	YY_RULE_SETUP
948	#line 59 "parse.fl"
949	return (PUBLIC);
950	YY_BREAK
951	case 31:
952	YY_RULE_SETUP
953	#line 60 "parse.fl"
954	return (TRUE);
955	YY_BREAK
956	case 32:
957	YY_RULE_SETUP
958	#line 61 "parse.fl"
959	return (FALSE);
960	YY_BREAK
961	case 33:
962	YY_RULE_SETUP
963	#line 62 "parse.fl"
964	return (DOCUMENT);
965	YY_BREAK
966	case 34:
967	YY_RULE_SETUP
968	#line 63 "parse.fl"
969	return (SECTION);
970	YY_BREAK
971	case 35:
972	YY_RULE_SETUP
973	#line 64 "parse.fl"
974	return (ICON);
975	YY_BREAK
976	case 36:
977	YY_RULE_SETUP
978	#line 65 "parse.fl"
979	return (SMALLICON);
980	YY_BREAK
981	case 37:
982	YY_RULE_SETUP
983	#line 66 "parse.fl"
984	{string=NULL;BEGIN(STRINGCOND);}
985	YY_BREAK
986
987	case 38:
988	YY_RULE_SETUP
989	#line 68 "parse.fl"
990	{/* append this to our current string EXC NEWLINE */
991	if (string==NULL) string_len=0; else
992	string_len=strlen(string);
993	string=realloc(string,string_len+strlen(yytext)+1);
994	/* +1 is for trailing \0 */
995	strcpy(string+string_len,yytext);
996	}
997	YY_BREAK
998	case 39:
999	YY_RULE_SETUP
1000	#line 75 "parse.fl"
1001	{/* append this to our current string - INC NEWLINE */
1002	lineno++;
1003	if (string==NULL) string_len=0; else
1004	string_len=strlen(string);
1005	string=realloc(string,string_len+strlen(yytext)+1);
1006	/* +1 is for trailing \0 */
1007	strcpy(string+string_len,yytext);
1008	}
1009	YY_BREAK
1010	case 40:
1011	#line 84 "parse.fl"
1012	case 41:
1013	YY_RULE_SETUP
1014	#line 84 "parse.fl"
1015	{ /replace quoted quote with one quote/
1016	string_len=strlen(string);
1017	string=realloc(string,string_len+2);
1018	string[string_len]='\"';
1019	string[string_len+1]='\0';
1020	}
1021	YY_BREAK
1022	case 42:
1023	YY_RULE_SETUP
1024	#line 90 "parse.fl"
1025	{
1026	BEGIN(INITIAL);
1027	yylval.string=string;
1028	return(STRING);
1029	/* note that the string may have long bits of
1030	whitespace in it that we could remove. */
1031	}
1032	YY_BREAK
1033
1034	case 43:
1035	YY_RULE_SETUP
1036	#line 98 "parse.fl"
1037	yylval.string=strdup(yytext);return (DATA);
1038	YY_BREAK
1039	case 44:
1040	YY_RULE_SETUP
1041	#line 99 "parse.fl"
1042	;
1043	YY_BREAK
1044	case 45:
1045	YY_RULE_SETUP
1046	#line 100 "parse.fl"
1047	lineno++;
1048	YY_BREAK
1049	case 46:
1050	YY_RULE_SETUP
1051	#line 101 "parse.fl"
1052	ECHO;
1053	YY_BREAK
1054	#line 1055 "parse.yy.c"
1055	case YY_STATE_EOF(INITIAL):
1056	case YY_STATE_EOF(STRINGCOND):
1057	yyterminate();
1058
1059	case YY_END_OF_BUFFER:
1060	{
1061	/* Amount of text matched not including the EOB char. */
1062	int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1063
1064	/* Undo the effects of YY_DO_BEFORE_ACTION. */
1065	*yy_cp = yy_hold_char;
1066	YY_RESTORE_YY_MORE_OFFSET
1067
1068	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1069	{
1070	/* We're scanning a new file or input source. It's
1071	* possible that this happened because the user
1072	* just pointed yyin at a new source and called
1073	* yylex(). If so, then we have to assure
1074	* consistency between yy_current_buffer and our
1075	* globals. Here is the right place to do so, because
1076	* this is the first action (other than possibly a
1077	* back-up) that will match for the new input source.
1078	*/
1079	yy_n_chars = yy_current_buffer->yy_n_chars;
1080	yy_current_buffer->yy_input_file = yyin;
1081	yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1082	}
1083
1084	/* Note that here we test for yy_c_buf_p "<=" to the position
1085	* of the first EOB in the buffer, since yy_c_buf_p will
1086	* already have been incremented past the NUL character
1087	* (since all states make transitions on EOB to the
1088	* end-of-buffer state). Contrast this with the test
1089	* in input().
1090	*/
1091	if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1092	{ /* This was really a NUL. */
1093	yy_state_type yy_next_state;
1094
1095	yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1096
1097	yy_current_state = yy_get_previous_state();
1098
1099	/* Okay, we're now positioned to make the NUL
1100	* transition. We couldn't have
1101	* yy_get_previous_state() go ahead and do it
1102	* for us because it doesn't know how to deal
1103	* with the possibility of jamming (and we don't
1104	* want to build jamming into it because then it
1105	* will run more slowly).
1106	*/
1107
1108	yy_next_state = yy_try_NUL_trans( yy_current_state );
1109
1110	yy_bp = yytext_ptr + YY_MORE_ADJ;
1111
1112	if ( yy_next_state )
1113	{
1114	/* Consume the NUL. */
1115	yy_cp = ++yy_c_buf_p;
1116	yy_current_state = yy_next_state;
1117	goto yy_match;
1118	}
1119
1120	else
1121	{
1122	yy_cp = yy_c_buf_p;
1123	goto yy_find_action;
1124	}
1125	}
1126
1127	else switch ( yy_get_next_buffer() )
1128	{
1129	case EOB_ACT_END_OF_FILE:
1130	{
1131	yy_did_buffer_switch_on_eof = 0;
1132
1133	if ( yywrap() )
1134	{
1135	/* Note: because we've taken care in
1136	* yy_get_next_buffer() to have set up
1137	* yytext, we can now set up
1138	* yy_c_buf_p so that if some total
1139	* hoser (like flex itself) wants to
1140	* call the scanner after we return the
1141	* YY_NULL, it'll still work - another
1142	* YY_NULL will get returned.
1143	*/
1144	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1145
1146	yy_act = YY_STATE_EOF(YY_START);
1147	goto do_action;
1148	}
1149
1150	else
1151	{
1152	if ( ! yy_did_buffer_switch_on_eof )
1153	YY_NEW_FILE;
1154	}
1155	break;
1156	}
1157
1158	case EOB_ACT_CONTINUE_SCAN:
1159	yy_c_buf_p =
1160	yytext_ptr + yy_amount_of_matched_text;
1161
1162	yy_current_state = yy_get_previous_state();
1163
1164	yy_cp = yy_c_buf_p;
1165	yy_bp = yytext_ptr + YY_MORE_ADJ;
1166	goto yy_match;
1167
1168	case EOB_ACT_LAST_MATCH:
1169	yy_c_buf_p =
1170	&yy_current_buffer->yy_ch_buf[yy_n_chars];
1171
1172	yy_current_state = yy_get_previous_state();
1173
1174	yy_cp = yy_c_buf_p;
1175	yy_bp = yytext_ptr + YY_MORE_ADJ;
1176	goto yy_find_action;
1177	}
1178	break;
1179	}
1180
1181	default:
1182	YY_FATAL_ERROR(
1183	"fatal flex scanner internal error--no action found" );
1184	} /* end of action switch */
1185	} /* end of scanning one token */
1186	} /* end of yylex */
1187
1188
1189	/* yy_get_next_buffer - try to read in a new buffer
1190	*
1191	* Returns a code representing an action:
1192	* EOB_ACT_LAST_MATCH -
1193	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1194	* EOB_ACT_END_OF_FILE - end of file
1195	*/
1196
1197	static int yy_get_next_buffer()
1198	{
1199	register char *dest = yy_current_buffer->yy_ch_buf;
1200	register char *source = yytext_ptr;
1201	register int number_to_move, i;
1202	int ret_val;
1203
1204	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1205	YY_FATAL_ERROR(
1206	"fatal flex scanner internal error--end of buffer missed" );
1207
1208	if ( yy_current_buffer->yy_fill_buffer == 0 )
1209	{ /* Don't try to fill the buffer, so this is an EOF. */
1210	if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1211	{
1212	/* We matched a single character, the EOB, so
1213	* treat this as a final EOF.
1214	*/
1215	return EOB_ACT_END_OF_FILE;
1216	}
1217
1218	else
1219	{
1220	/* We matched some text prior to the EOB, first
1221	* process it.
1222	*/
1223	return EOB_ACT_LAST_MATCH;
1224	}
1225	}
1226
1227	/* Try to read more data. */
1228
1229	/* First move last chars to start of buffer. */
1230	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1231
1232	for ( i = 0; i < number_to_move; ++i )
1233	(dest++) = (source++);
1234
1235	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1236	/* don't do the read, it's not guaranteed to return an EOF,
1237	* just force an EOF
1238	*/
1239	yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1240
1241	else
1242	{
1243	int num_to_read =
1244	yy_current_buffer->yy_buf_size - number_to_move - 1;
1245
1246	while ( num_to_read <= 0 )
1247	{ /* Not enough room in the buffer - grow it. */
1248	#ifdef YY_USES_REJECT
1249	YY_FATAL_ERROR(
1250	"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1251	#else
1252
1253	/* just a shorter name for the current buffer */
1254	YY_BUFFER_STATE b = yy_current_buffer;
1255
1256	int yy_c_buf_p_offset =
1257	(int) (yy_c_buf_p - b->yy_ch_buf);
1258
1259	if ( b->yy_is_our_buffer )
1260	{
1261	int new_size = b->yy_buf_size * 2;
1262
1263	if ( new_size <= 0 )
1264	b->yy_buf_size += b->yy_buf_size / 8;
1265	else
1266	b->yy_buf_size *= 2;
1267
1268	b->yy_ch_buf = (char *)
1269	/* Include room in for 2 EOB chars. */
1270	yy_flex_realloc( (void *) b->yy_ch_buf,
1271	b->yy_buf_size + 2 );
1272	}
1273	else
1274	/* Can't grow it, we don't own it. */
1275	b->yy_ch_buf = 0;
1276
1277	if ( ! b->yy_ch_buf )
1278	YY_FATAL_ERROR(
1279	"fatal error - scanner input buffer overflow" );
1280
1281	yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1282
1283	num_to_read = yy_current_buffer->yy_buf_size -
1284	number_to_move - 1;
1285	#endif
1286	}
1287
1288	if ( num_to_read > YY_READ_BUF_SIZE )
1289	num_to_read = YY_READ_BUF_SIZE;
1290
1291	/* Read in more data. */
1292	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1293	yy_n_chars, num_to_read );
1294
1295	yy_current_buffer->yy_n_chars = yy_n_chars;
1296	}
1297
1298	if ( yy_n_chars == 0 )
1299	{
1300	if ( number_to_move == YY_MORE_ADJ )
1301	{
1302	ret_val = EOB_ACT_END_OF_FILE;
1303	yyrestart( yyin );
1304	}
1305
1306	else
1307	{
1308	ret_val = EOB_ACT_LAST_MATCH;
1309	yy_current_buffer->yy_buffer_status =
1310	YY_BUFFER_EOF_PENDING;
1311	}
1312	}
1313
1314	else
1315	ret_val = EOB_ACT_CONTINUE_SCAN;
1316
1317	yy_n_chars += number_to_move;
1318	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1319	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1320
1321	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1322
1323	return ret_val;
1324	}
1325
1326
1327	/* yy_get_previous_state - get the state just before the EOB char was reached */
1328
1329	static yy_state_type yy_get_previous_state()
1330	{
1331	register yy_state_type yy_current_state;
1332	register char *yy_cp;
1333
1334	yy_current_state = yy_start;
1335	yy_current_state += YY_AT_BOL();
1336
1337	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1338	{
1339	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
1340	if ( yy_accept[yy_current_state] )
1341	{
1342	yy_last_accepting_state = yy_current_state;
1343	yy_last_accepting_cpos = yy_cp;
1344	}
1345	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1346	{
1347	yy_current_state = (int) yy_def[yy_current_state];
1348	if ( yy_current_state >= 274 )
1349	yy_c = yy_meta[(unsigned int) yy_c];
1350	}
1351	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1352	}
1353
1354	return yy_current_state;
1355	}
1356
1357
1358	/* yy_try_NUL_trans - try to make a transition on the NUL character
1359	*
1360	* synopsis
1361	* next_state = yy_try_NUL_trans( current_state );
1362	*/
1363
1364	#ifdef YY_USE_PROTOS
1365	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1366	#else
1367	static yy_state_type yy_try_NUL_trans( yy_current_state )
1368	yy_state_type yy_current_state;
1369	#endif
1370	{
1371	register int yy_is_jam;
1372	register char *yy_cp = yy_c_buf_p;
1373
1374	register YY_CHAR yy_c = 1;
1375	if ( yy_accept[yy_current_state] )
1376	{
1377	yy_last_accepting_state = yy_current_state;
1378	yy_last_accepting_cpos = yy_cp;
1379	}
1380	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1381	{
1382	yy_current_state = (int) yy_def[yy_current_state];
1383	if ( yy_current_state >= 274 )
1384	yy_c = yy_meta[(unsigned int) yy_c];
1385	}
1386	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1387	yy_is_jam = (yy_current_state == 273);
1388
1389	return yy_is_jam ? 0 : yy_current_state;
1390	}
1391
1392
1393	#ifndef YY_NO_UNPUT
1394	#ifdef YY_USE_PROTOS
1395	static void yyunput( int c, register char *yy_bp )
1396	#else
1397	static void yyunput( c, yy_bp )
1398	int c;
1399	register char *yy_bp;
1400	#endif
1401	{
1402	register char *yy_cp = yy_c_buf_p;
1403
1404	/* undo effects of setting up yytext */
1405	*yy_cp = yy_hold_char;
1406
1407	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1408	{ /* need to shift things up to make room */
1409	/* +2 for EOB chars. */
1410	register int number_to_move = yy_n_chars + 2;
1411	register char *dest = &yy_current_buffer->yy_ch_buf[
1412	yy_current_buffer->yy_buf_size + 2];
1413	register char *source =
1414	&yy_current_buffer->yy_ch_buf[number_to_move];
1415
1416	while ( source > yy_current_buffer->yy_ch_buf )
1417	--dest = --source;
1418
1419	yy_cp += (int) (dest - source);
1420	yy_bp += (int) (dest - source);
1421	yy_current_buffer->yy_n_chars =
1422	yy_n_chars = yy_current_buffer->yy_buf_size;
1423
1424	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1425	YY_FATAL_ERROR( "flex scanner push-back overflow" );
1426	}
1427
1428	*--yy_cp = (char) c;
1429
1430
1431	yytext_ptr = yy_bp;
1432	yy_hold_char = *yy_cp;
1433	yy_c_buf_p = yy_cp;
1434	}
1435	#endif /* ifndef YY_NO_UNPUT */
1436
1437
1438	#ifdef __cplusplus
1439	static int yyinput()
1440	#else
1441	static int input()
1442	#endif
1443	{
1444	int c;
1445
1446	*yy_c_buf_p = yy_hold_char;
1447
1448	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1449	{
1450	/* yy_c_buf_p now points to the character we want to return.
1451	* If this occurs before the EOB characters, then it's a
1452	* valid NUL; if not, then we've hit the end of the buffer.
1453	*/
1454	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1455	/* This was really a NUL. */
1456	*yy_c_buf_p = '\0';
1457
1458	else
1459	{ /* need more input */
1460	int offset = yy_c_buf_p - yytext_ptr;
1461	++yy_c_buf_p;
1462
1463	switch ( yy_get_next_buffer() )
1464	{
1465	case EOB_ACT_LAST_MATCH:
1466	/* This happens because yy_g_n_b()
1467	* sees that we've accumulated a
1468	* token and flags that we need to
1469	* try matching the token before
1470	* proceeding. But for input(),
1471	* there's no matching to consider.
1472	* So convert the EOB_ACT_LAST_MATCH
1473	* to EOB_ACT_END_OF_FILE.
1474	*/
1475
1476	/* Reset buffer status. */
1477	yyrestart( yyin );
1478
1479	/* fall through */
1480
1481	case EOB_ACT_END_OF_FILE:
1482	{
1483	if ( yywrap() )
1484	return EOF;
1485
1486	if ( ! yy_did_buffer_switch_on_eof )
1487	YY_NEW_FILE;
1488	#ifdef __cplusplus
1489	return yyinput();
1490	#else
1491	return input();
1492	#endif
1493	}
1494
1495	case EOB_ACT_CONTINUE_SCAN:
1496	yy_c_buf_p = yytext_ptr + offset;
1497	break;
1498	}
1499	}
1500	}
1501
1502	c = (unsigned char ) yy_c_buf_p; /* cast for 8-bit char's */
1503	yy_c_buf_p = '\0'; / preserve yytext */
1504	yy_hold_char = *++yy_c_buf_p;
1505
1506	yy_current_buffer->yy_at_bol = (c == '\n');
1507
1508	return c;
1509	}
1510
1511
1512	#ifdef YY_USE_PROTOS
1513	void yyrestart( FILE *input_file )
1514	#else
1515	void yyrestart( input_file )
1516	FILE *input_file;
1517	#endif
1518	{
1519	if ( ! yy_current_buffer )
1520	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1521
1522	yy_init_buffer( yy_current_buffer, input_file );
1523	yy_load_buffer_state();
1524	}
1525
1526
1527	#ifdef YY_USE_PROTOS
1528	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1529	#else
1530	void yy_switch_to_buffer( new_buffer )
1531	YY_BUFFER_STATE new_buffer;
1532	#endif
1533	{
1534	if ( yy_current_buffer == new_buffer )
1535	return;
1536
1537	if ( yy_current_buffer )
1538	{
1539	/* Flush out information for old buffer. */
1540	*yy_c_buf_p = yy_hold_char;
1541	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1542	yy_current_buffer->yy_n_chars = yy_n_chars;
1543	}
1544
1545	yy_current_buffer = new_buffer;
1546	yy_load_buffer_state();
1547
1548	/* We don't actually know whether we did this switch during
1549	* EOF (yywrap()) processing, but the only time this flag
1550	* is looked at is after yywrap() is called, so it's safe
1551	* to go ahead and always set it.
1552	*/
1553	yy_did_buffer_switch_on_eof = 1;
1554	}
1555
1556
1557	#ifdef YY_USE_PROTOS
1558	void yy_load_buffer_state( void )
1559	#else
1560	void yy_load_buffer_state()
1561	#endif
1562	{
1563	yy_n_chars = yy_current_buffer->yy_n_chars;
1564	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1565	yyin = yy_current_buffer->yy_input_file;
1566	yy_hold_char = *yy_c_buf_p;
1567	}
1568
1569
1570	#ifdef YY_USE_PROTOS
1571	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1572	#else
1573	YY_BUFFER_STATE yy_create_buffer( file, size )
1574	FILE *file;
1575	int size;
1576	#endif
1577	{
1578	YY_BUFFER_STATE b;
1579
1580	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1581	if ( ! b )
1582	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1583
1584	b->yy_buf_size = size;
1585
1586	/* yy_ch_buf has to be 2 characters longer than the size given because
1587	* we need to put in 2 end-of-buffer characters.
1588	*/
1589	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1590	if ( ! b->yy_ch_buf )
1591	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1592
1593	b->yy_is_our_buffer = 1;
1594
1595	yy_init_buffer( b, file );
1596
1597	return b;
1598	}
1599
1600
1601	#ifdef YY_USE_PROTOS
1602	void yy_delete_buffer( YY_BUFFER_STATE b )
1603	#else
1604	void yy_delete_buffer( b )
1605	YY_BUFFER_STATE b;
1606	#endif
1607	{
1608	if ( ! b )
1609	return;
1610
1611	if ( b == yy_current_buffer )
1612	yy_current_buffer = (YY_BUFFER_STATE) 0;
1613
1614	if ( b->yy_is_our_buffer )
1615	yy_flex_free( (void *) b->yy_ch_buf );
1616
1617	yy_flex_free( (void *) b );
1618	}
1619
1620
1621	#ifndef YY_ALWAYS_INTERACTIVE
1622	#ifndef YY_NEVER_INTERACTIVE
1623	extern int isatty YY_PROTO(( int ));
1624	#endif
1625	#endif
1626
1627	#ifdef YY_USE_PROTOS
1628	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1629	#else
1630	void yy_init_buffer( b, file )
1631	YY_BUFFER_STATE b;
1632	FILE *file;
1633	#endif
1634
1635
1636	{
1637	yy_flush_buffer( b );
1638
1639	b->yy_input_file = file;
1640	b->yy_fill_buffer = 1;
1641
1642	#if YY_ALWAYS_INTERACTIVE
1643	b->yy_is_interactive = 1;
1644	#else
1645	#if YY_NEVER_INTERACTIVE
1646	b->yy_is_interactive = 0;
1647	#else
1648	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1649	#endif
1650	#endif
1651	}
1652
1653
1654	#ifdef YY_USE_PROTOS
1655	void yy_flush_buffer( YY_BUFFER_STATE b )
1656	#else
1657	void yy_flush_buffer( b )
1658	YY_BUFFER_STATE b;
1659	#endif
1660
1661	{
1662	if ( ! b )
1663	return;
1664
1665	b->yy_n_chars = 0;
1666
1667	/* We always need two end-of-buffer characters. The first causes
1668	* a transition to the end-of-buffer state. The second causes
1669	* a jam in that state.
1670	*/
1671	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1672	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1673
1674	b->yy_buf_pos = &b->yy_ch_buf[0];
1675
1676	b->yy_at_bol = 1;
1677	b->yy_buffer_status = YY_BUFFER_NEW;
1678
1679	if ( b == yy_current_buffer )
1680	yy_load_buffer_state();
1681	}
1682
1683
1684	#ifndef YY_NO_SCAN_BUFFER
1685	#ifdef YY_USE_PROTOS
1686	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1687	#else
1688	YY_BUFFER_STATE yy_scan_buffer( base, size )
1689	char *base;
1690	yy_size_t size;
1691	#endif
1692	{
1693	YY_BUFFER_STATE b;
1694
1695	if ( size < 2 \|\|
1696	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
1697	base[size-1] != YY_END_OF_BUFFER_CHAR )
1698	/* They forgot to leave room for the EOB's. */
1699	return 0;
1700
1701	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1702	if ( ! b )
1703	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1704
1705	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1706	b->yy_buf_pos = b->yy_ch_buf = base;
1707	b->yy_is_our_buffer = 0;
1708	b->yy_input_file = 0;
1709	b->yy_n_chars = b->yy_buf_size;
1710	b->yy_is_interactive = 0;
1711	b->yy_at_bol = 1;
1712	b->yy_fill_buffer = 0;
1713	b->yy_buffer_status = YY_BUFFER_NEW;
1714
1715	yy_switch_to_buffer( b );
1716
1717	return b;
1718	}
1719	#endif
1720
1721
1722	#ifndef YY_NO_SCAN_STRING
1723	#ifdef YY_USE_PROTOS
1724	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1725	#else
1726	YY_BUFFER_STATE yy_scan_string( yy_str )
1727	yyconst char *yy_str;
1728	#endif
1729	{
1730	int len;
1731	for ( len = 0; yy_str[len]; ++len )
1732	;
1733
1734	return yy_scan_bytes( yy_str, len );
1735	}
1736	#endif
1737
1738
1739	#ifndef YY_NO_SCAN_BYTES
1740	#ifdef YY_USE_PROTOS
1741	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1742	#else
1743	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1744	yyconst char *bytes;
1745	int len;
1746	#endif
1747	{
1748	YY_BUFFER_STATE b;
1749	char *buf;
1750	yy_size_t n;
1751	int i;
1752
1753	/* Get memory for full buffer, including space for trailing EOB's. */
1754	n = len + 2;
1755	buf = (char *) yy_flex_alloc( n );
1756	if ( ! buf )
1757	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1758
1759	for ( i = 0; i < len; ++i )
1760	buf[i] = bytes[i];
1761
1762	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1763
1764	b = yy_scan_buffer( buf, n );
1765	if ( ! b )
1766	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1767
1768	/* It's okay to grow etc. this buffer, and we should throw it
1769	* away when we're done.
1770	*/
1771	b->yy_is_our_buffer = 1;
1772
1773	return b;
1774	}
1775	#endif
1776
1777
1778	#ifndef YY_NO_PUSH_STATE
1779	#ifdef YY_USE_PROTOS
1780	static void yy_push_state( int new_state )
1781	#else
1782	static void yy_push_state( new_state )
1783	int new_state;
1784	#endif
1785	{
1786	if ( yy_start_stack_ptr >= yy_start_stack_depth )
1787	{
1788	yy_size_t new_size;
1789
1790	yy_start_stack_depth += YY_START_STACK_INCR;
1791	new_size = yy_start_stack_depth * sizeof( int );
1792
1793	if ( ! yy_start_stack )
1794	yy_start_stack = (int *) yy_flex_alloc( new_size );
1795
1796	else
1797	yy_start_stack = (int *) yy_flex_realloc(
1798	(void *) yy_start_stack, new_size );
1799
1800	if ( ! yy_start_stack )
1801	YY_FATAL_ERROR(
1802	"out of memory expanding start-condition stack" );
1803	}
1804
1805	yy_start_stack[yy_start_stack_ptr++] = YY_START;
1806
1807	BEGIN(new_state);
1808	}
1809	#endif
1810
1811
1812	#ifndef YY_NO_POP_STATE
1813	static void yy_pop_state()
1814	{
1815	if ( --yy_start_stack_ptr < 0 )
1816	YY_FATAL_ERROR( "start-condition stack underflow" );
1817
1818	BEGIN(yy_start_stack[yy_start_stack_ptr]);
1819	}
1820	#endif
1821
1822
1823	#ifndef YY_NO_TOP_STATE
1824	static int yy_top_state()
1825	{
1826	return yy_start_stack[yy_start_stack_ptr - 1];
1827	}
1828	#endif
1829
1830	#ifndef YY_EXIT_FAILURE
1831	#define YY_EXIT_FAILURE 2
1832	#endif
1833
1834	#ifdef YY_USE_PROTOS
1835	static void yy_fatal_error( yyconst char msg[] )
1836	#else
1837	static void yy_fatal_error( msg )
1838	char msg[];
1839	#endif
1840	{
1841	(void) fprintf( stderr, "%s\n", msg );
1842	exit( YY_EXIT_FAILURE );
1843	}
1844
1845
1846
1847	/* Redefine yyless() so it works in section 3 code. */
1848
1849	#undef yyless
1850	#define yyless(n) \
1851	do \
1852	{ \
1853	/* Undo effects of setting up yytext. */ \
1854	yytext[yyleng] = yy_hold_char; \
1855	yy_c_buf_p = yytext + n; \
1856	yy_hold_char = *yy_c_buf_p; \
1857	*yy_c_buf_p = '\0'; \
1858	yyleng = n; \
1859	} \
1860	while ( 0 )
1861
1862
1863	/* Internal utility routines. */
1864
1865	#ifndef yytext_ptr
1866	#ifdef YY_USE_PROTOS
1867	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
1868	#else
1869	static void yy_flex_strncpy( s1, s2, n )
1870	char *s1;
1871	yyconst char *s2;
1872	int n;
1873	#endif
1874	{
1875	register int i;
1876	for ( i = 0; i < n; ++i )
1877	s1[i] = s2[i];
1878	}
1879	#endif
1880
1881	#ifdef YY_NEED_STRLEN
1882	#ifdef YY_USE_PROTOS
1883	static int yy_flex_strlen( yyconst char *s )
1884	#else
1885	static int yy_flex_strlen( s )
1886	yyconst char *s;
1887	#endif
1888	{
1889	register int n;
1890	for ( n = 0; s[n]; ++n )
1891	;
1892
1893	return n;
1894	}
1895	#endif
1896
1897
1898	#ifdef YY_USE_PROTOS
1899	static void *yy_flex_alloc( yy_size_t size )
1900	#else
1901	static void *yy_flex_alloc( size )
1902	yy_size_t size;
1903	#endif
1904	{
1905	return (void *) malloc( size );
1906	}
1907
1908	#ifdef YY_USE_PROTOS
1909	static void yy_flex_realloc( void ptr, yy_size_t size )
1910	#else
1911	static void *yy_flex_realloc( ptr, size )
1912	void *ptr;
1913	yy_size_t size;
1914	#endif
1915	{
1916	/* The cast to (char *) in the following accommodates both
1917	* implementations that use char* generic pointers, and those
1918	* that use void* generic pointers. It works with the latter
1919	* because both ANSI C and C++ allow castless assignment from
1920	* any pointer type to void*, and deal with argument conversions
1921	* as though doing an assignment.
1922	*/
1923	return (void ) realloc( (char ) ptr, size );
1924	}
1925
1926	#ifdef YY_USE_PROTOS
1927	static void yy_flex_free( void *ptr )
1928	#else
1929	static void yy_flex_free( ptr )
1930	void *ptr;
1931	#endif
1932	{
1933	free( ptr );
1934	}
1935
1936	#if YY_MAIN
1937	int main()
1938	{
1939	yylex();
1940	return 0;
1941	}
1942	#endif
1943	#line 101 "parse.fl"
1944
1945	/****** deleted rules: *****
1946	en return(EN);
1947	fr return(FR);
1948	mi return(MI);
1949	zh return(ZH);
1950	de return(DE);
1951	***************/
1952
1953
1954
1955

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

Download in other formats: