Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/gsdl/src/recpt/zparse.yy.c@ 10705

Last change on this file since 10705 was 10705, checked in by jrm21, 19 years ago
tidied up interaction between flex/bison and greenstone's z3950 client classes. renamed parse.y to zparse.y to make it more obvious it's related to that stuff.
Property svn:keywords set to `Author Date Id Revision`
File size: 50.4 KB

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

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

Download in other formats: