Context Navigation

source: git/Singular/libparse.cc @ 667ba1

spielwiese

Last change on this file since 667ba1 was 762407, checked in by Oleksandr Motsak <motsak@…>, 12 years ago
config.h is for sources files only FIX: config.h should only be used by source (not from inside kernel/mod2.h!) NOTE: each source file should better include mod2.h right after config.h, while headers should better not include mod2.h.
Property mode set to `100644`
File size: 107.1 KB

Line
1	#define yy_create_buffer yylp_create_buffer
2	#define yy_delete_buffer yylp_delete_buffer
3	#define yy_scan_buffer yylp_scan_buffer
4	#define yy_scan_string yylp_scan_string
5	#define yy_scan_bytes yylp_scan_bytes
6	#define yy_flex_debug yylp_flex_debug
7	#define yy_init_buffer yylp_init_buffer
8	#define yy_flush_buffer yylp_flush_buffer
9	#define yy_load_buffer_state yylp_load_buffer_state
10	#define yy_switch_to_buffer yylp_switch_to_buffer
11	#define yyin yylpin
12	#define yyleng yylpleng
13	#define yylex yylplex
14	#define yyout yylpout
15	#define yyrestart yylprestart
16	#define yytext yylptext
17	#define yywrap yylpwrap
18
19	/* A lexical scanner generated by flex */
20
21	/* Scanner skeleton version:
22	* $Header: /exports/cvsroot-2/cvsroot/Singular/libparse.cc,v 1.15 2009-07-28 15:22:17 Singular Exp $
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
31
32	/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
33	#ifdef c_plusplus
34	#ifndef __cplusplus
35	#define __cplusplus
36	#endif
37	#endif
38
39
40	#ifdef __cplusplus
41
42	#include <stdlib.h>
43	#include <unistd.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	typedef unsigned char YY_CHAR;
283	FILE yyin = (FILE ) 0, yyout = (FILE ) 0;
284	typedef int yy_state_type;
285	extern char *yytext;
286	#define yytext_ptr yytext
287
288	static yy_state_type yy_get_previous_state YY_PROTO(( void ));
289	static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
290	static int yy_get_next_buffer YY_PROTO(( void ));
291	static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
292
293	/* Done after the current pattern has been matched and before the
294	* corresponding action - sets up yytext.
295	*/
296	#define YY_DO_BEFORE_ACTION \
297	yytext_ptr = yy_bp; \
298	yytext_ptr -= yy_more_len; \
299	yyleng = (int) (yy_cp - yytext_ptr); \
300	yy_hold_char = *yy_cp; \
301	*yy_cp = '\0'; \
302	yy_c_buf_p = yy_cp;
303
304	#define YY_NUM_RULES 96
305	#define YY_END_OF_BUFFER 97
306	static yyconst short int yy_accept[485] =
307	{ 0,
308	0, 0, 0, 0, 28, 28, 0, 0, 0, 0,
309	0, 0, 0, 0, 0, 0, 49, 49, 0, 0,
310	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
311	0, 0, 0, 0, 0, 0, 0, 0, 97, 95,
312	1, 92, 93, 2, 94, 95, 95, 95, 95, 95,
313	95, 95, 95, 95, 20, 19, 20, 20, 20, 20,
314	20, 20, 20, 20, 29, 28, 27, 29, 29, 29,
315	29, 29, 29, 29, 29, 96, 30, 96, 96, 96,
316	39, 32, 36, 33, 34, 38, 35, 43, 43, 96,
317	43, 43, 43, 43, 43, 43, 42, 47, 46, 47,
318
319	45, 49, 51, 48, 50, 63, 62, 53, 58, 59,
320	63, 60, 61, 63, 56, 57, 83, 82, 75, 78,
321	79, 83, 80, 81, 76, 77, 88, 87, 84, 88,
322	73, 72, 70, 73, 91, 90, 91, 66, 65, 64,
323	69, 68, 67, 0, 1, 0, 0, 0, 0, 0,
324	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
325	0, 0, 0, 28, 28, 0, 0, 0, 0, 0,
326	0, 0, 0, 30, 0, 31, 0, 0, 37, 0,
327	0, 0, 0, 0, 0, 0, 42, 0, 0, 0,
328	0, 0, 42, 42, 44, 49, 52, 0, 74, 86,
329
330	85, 71, 89, 0, 1, 1, 0, 1, 0, 0,
331	0, 0, 0, 0, 0, 0, 0, 0, 14, 13,
332	0, 0, 0, 0, 0, 0, 28, 28, 28, 28,
333	22, 21, 0, 0, 0, 0, 0, 0, 37, 37,
334	0, 0, 0, 41, 0, 42, 0, 0, 0, 0,
335	0, 52, 0, 74, 0, 0, 0, 1, 0, 0,
336	0, 0, 0, 0, 0, 0, 0, 0, 14, 13,
337	13, 0, 0, 0, 0, 0, 0, 0, 28, 22,
338	21, 21, 0, 0, 0, 0, 0, 0, 0, 0,
339	0, 41, 0, 0, 40, 0, 41, 0, 0, 0,
340
341	10, 11, 0, 0, 0, 0, 0, 0, 0, 0,
342	0, 0, 0, 13, 0, 0, 0, 0, 16, 0,
343	17, 0, 15, 21, 0, 0, 0, 0, 23, 0,
344	25, 0, 24, 0, 0, 40, 0, 0, 0, 0,
345	0, 0, 0, 0, 0, 8, 8, 7, 0, 0,
346	5, 0, 0, 0, 0, 12, 0, 0, 0, 18,
347	0, 0, 0, 26, 0, 0, 0, 0, 0, 55,
348	0, 0, 8, 8, 0, 9, 0, 0, 3, 0,
349	0, 8, 8, 8, 5, 5, 0, 0, 12, 12,
350	12, 0, 0, 0, 0, 0, 0, 8, 8, 8,
351
352	0, 3, 3, 0, 0, 0, 0, 0, 0, 0,
353	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
354	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
355	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
356	0, 6, 0, 0, 12, 0, 0, 0, 0, 0,
357	0, 54, 0, 0, 0, 0, 0, 4, 0, 0,
358	6, 6, 12, 12, 12, 0, 0, 0, 0, 0,
359	0, 0, 4, 4, 0, 0, 0, 0, 0, 0,
360	0, 0, 0, 0
361	} ;
362
363	static yyconst int yy_ec[256] =
364	{ 0,
365	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
366	1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
367	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
368	1, 5, 6, 7, 8, 9, 10, 11, 12, 13,
369	14, 15, 11, 16, 11, 10, 17, 18, 18, 18,
370	18, 18, 18, 18, 18, 18, 18, 19, 20, 11,
371	21, 11, 11, 12, 22, 23, 22, 22, 22, 22,
372	22, 24, 25, 22, 22, 26, 22, 22, 22, 22,
373	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
374	27, 28, 29, 30, 31, 11, 32, 22, 33, 34,
375
376	35, 36, 37, 22, 38, 22, 22, 39, 40, 41,
377	42, 43, 22, 44, 45, 46, 47, 48, 22, 49,
378	50, 22, 51, 11, 52, 11, 1, 1, 1, 1,
379	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
380	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
381	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
382	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
383	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
385	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386
387	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
388	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
389	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
391	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
392	1, 1, 1, 1, 1
393	} ;
394
395	static yyconst int yy_meta[53] =
396	{ 0,
397	1, 2, 3, 4, 2, 1, 5, 6, 1, 5,
398	1, 7, 8, 9, 5, 10, 5, 11, 5, 1,
399	1, 7, 7, 7, 7, 7, 1, 1, 1, 5,
400	7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
401	7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
402	4, 1
403	} ;
404
405	static yyconst short int yy_base[533] =
406	{ 0,
407	0, 47, 6, 93, 140, 187, 235, 287, 339, 391,
408	5, 11, 443, 0, 9, 12, 63, 69, 493, 543,
409	0, 0, 593, 643, 72, 80, 81, 90, 26, 31,
410	24, 52, 54, 95, 0, 0, 0, 0, 1250, 2200,
411	1202, 2200, 2200, 1226, 2200, 1213, 1221, 1183, 1164, 1170,
412	1162, 1105, 1106, 1114, 2200, 2200, 1131, 61, 1115, 1105,
413	1100, 1108, 1117, 1096, 2200, 84, 2200, 1121, 95, 1105,
414	1095, 1091, 1098, 1100, 1073, 2200, 2200, 1109, 1099, 1101,
415	2200, 2200, 2200, 2200, 2200, 1083, 2200, 2200, 694, 0,
416	0, 125, 745, 144, 151, 157, 2200, 2200, 2200, 1048,
417
418	2200, 99, 2200, 2200, 2200, 2200, 2200, 2200, 2200, 2200,
419	1080, 2200, 2200, 1052, 2200, 2200, 2200, 2200, 2200, 2200,
420	2200, 1073, 2200, 2200, 2200, 2200, 2200, 2200, 2200, 4,
421	2200, 2200, 2200, 14, 2200, 2200, 1071, 2200, 2200, 2200,
422	2200, 2200, 2200, 1041, 1066, 1056, 1071, 1029, 1042, 1032,
423	1024, 1033, 1024, 1002, 163, 1039, 1027, 984, 992, 983,
424	976, 986, 966, 111, 796, 985, 972, 941, 945, 936,
425	874, 894, 874, 2200, 908, 2200, 900, 906, 895, 0,
426	0, 172, 0, 179, 191, 207, 2200, 904, 903, 219,
427	902, 74, 847, 198, 2200, 119, 0, 866, 0, 2200,
428
429	2200, 2200, 2200, 865, 0, 889, 213, 0, 869, 760,
430	757, 659, 645, 263, 645, 245, 82, 672, 0, 671,
431	651, 643, 274, 639, 132, 650, 665, 651, 649, 642,
432	0, 632, 612, 601, 278, 593, 133, 601, 0, 611,
433	318, 324, 330, 0, 375, 612, 0, 0, 381, 0,
434	609, 0, 578, 0, 576, 349, 594, 0, 562, 555,
435	368, 161, 559, 404, 509, 547, 548, 547, 0, 0,
436	560, 538, 500, 412, 522, 536, 422, 564, 0, 0,
437	0, 551, 530, 550, 530, 559, 527, 571, 553, 586,
438	610, 2200, 622, 628, 0, 307, 2200, 536, 226, 214,
439
440	2200, 2200, 507, 509, 600, 660, 577, 514, 898, 918,
441	495, 491, 500, 501, 475, 637, 969, 975, 2200, 473,
442	2200, 502, 2200, 491, 459, 650, 981, 990, 2200, 457,
443	2200, 491, 2200, 996, 1001, 0, 646, 1051, 1010, 1101,
444	1005, 453, 406, 1014, 1151, 121, 2200, 2200, 433, 432,
445	0, 431, 430, 390, 396, 1203, 384, 1022, 381, 2200,
446	369, 1055, 362, 2200, 1029, 227, 370, 270, 526, 2200,
447	269, 0, 287, 2200, 349, 2200, 380, 358, 0, 357,
448	350, 288, 318, 343, 2200, 348, 1046, 312, 0, 1255,
449	311, 274, 1068, 254, 1089, 1093, 1076, 345, 403, 405,
450
451	1223, 2200, 290, 1118, 1124, 241, 1231, 1216, 1244, 1237,
452	1275, 1287, 1110, 101, 1307, 1293, 1314, 1344, 1334, 1351,
453	1364, 1374, 1394, 254, 1445, 1449, 1455, 1469, 1475, 1481,
454	662, 1300, 238, 0, 239, 1313, 154, 1490, 1510, 245,
455	200, 0, 199, 192, 1562, 1590, 1596, 1591, 605, 214,
456	1035, 2200, 1610, 1332, 1607, 190, 184, 0, 143, 137,
457	2200, 126, 0, 1641, 103, 1622, 155, 1692, 1655, 1673,
458	1722, 1712, 2200, 104, 1618, 0, 91, 1685, 220, 1728,
459	656, 230, 1734, 2200, 1765, 1776, 1787, 1798, 1809, 1820,
460	1831, 1842, 1853, 1864, 1875, 1886, 1897, 1908, 1919, 1926,
461
462	1933, 1944, 1955, 1966, 1977, 1988, 1999, 2010, 2021, 2032,
463	2042, 2048, 2054, 2064, 2065, 2076, 92, 2081, 2092, 2102,
464	2112, 2118, 2124, 2129, 51, 2140, 2150, 2160, 2167, 2177,
465	2183, 2188
466	} ;
467
468	static yyconst short int yy_def[533] =
469	{ 0,
470	485, 485, 486, 486, 487, 487, 488, 488, 489, 489,
471	490, 490, 484, 13, 491, 491, 492, 492, 493, 493,
472	492, 492, 494, 494, 495, 495, 496, 496, 497, 497,
473	498, 498, 499, 499, 492, 492, 492, 492, 484, 484,
474	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
475	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
476	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
477	484, 484, 484, 484, 484, 484, 484, 500, 484, 501,
478	484, 484, 484, 484, 484, 484, 484, 484, 484, 89,
479	89, 89, 484, 89, 89, 89, 484, 484, 484, 484,
480
481	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
482	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
483	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
484	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
485	484, 484, 484, 484, 502, 484, 484, 484, 484, 484,
486	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
487	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
488	484, 484, 484, 484, 500, 484, 484, 501, 503, 89,
489	89, 89, 93, 89, 89, 89, 484, 93, 93, 93,
490	93, 93, 484, 89, 484, 484, 504, 484, 505, 484,
491
492	484, 484, 484, 484, 502, 502, 484, 506, 484, 484,
493	484, 484, 484, 484, 484, 484, 484, 484, 507, 508,
494	484, 484, 484, 484, 484, 484, 165, 165, 165, 165,
495	509, 510, 484, 484, 484, 484, 484, 484, 503, 503,
496	89, 93, 93, 193, 93, 93, 193, 193, 484, 193,
497	193, 504, 484, 505, 484, 484, 484, 506, 484, 484,
498	484, 484, 484, 484, 484, 484, 484, 484, 507, 508,
499	508, 484, 484, 484, 484, 484, 484, 484, 165, 509,
500	510, 510, 484, 484, 484, 484, 484, 484, 484, 89,
501	89, 484, 93, 93, 193, 484, 484, 193, 511, 484,
502
503	484, 484, 484, 484, 484, 484, 512, 484, 484, 484,
504	484, 484, 484, 508, 484, 484, 484, 484, 484, 484,
505	484, 484, 484, 510, 484, 484, 484, 484, 484, 484,
506	484, 484, 484, 193, 193, 193, 511, 513, 511, 513,
507	514, 484, 484, 484, 484, 515, 484, 484, 310, 310,
508	310, 310, 310, 484, 484, 516, 484, 484, 484, 484,
509	484, 484, 484, 484, 484, 340, 517, 340, 340, 484,
510	339, 340, 518, 484, 484, 484, 345, 345, 345, 345,
511	345, 515, 515, 515, 484, 310, 484, 484, 519, 516,
512	390, 484, 484, 484, 484, 520, 521, 518, 518, 518,
513
514	484, 484, 345, 484, 484, 484, 484, 484, 484, 484,
515	484, 484, 522, 484, 523, 520, 520, 523, 521, 484,
516	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
517	524, 484, 525, 418, 484, 417, 417, 484, 484, 423,
518	423, 423, 423, 423, 526, 484, 484, 524, 484, 484,
519	484, 484, 527, 528, 524, 439, 439, 439, 439, 439,
520	484, 423, 529, 526, 464, 530, 484, 531, 527, 527,
521	531, 528, 484, 439, 532, 471, 484, 470, 470, 532,
522	484, 484, 532, 0, 484, 484, 484, 484, 484, 484,
523	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
524
525	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
526	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
527	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
528	484, 484
529	} ;
530
531	static yyconst short int yy_nxt[2253] =
532	{ 0,
533	484, 41, 42, 43, 41, 484, 82, 83, 56, 82,
534	200, 99, 82, 83, 99, 82, 44, 84, 85, 45,
535	202, 86, 57, 84, 85, 46, 139, 86, 136, 47,
536	140, 201, 48, 136, 49, 58, 100, 50, 59, 100,
537	137, 202, 51, 60, 52, 137, 53, 54, 41, 42,
538	43, 41, 61, 62, 139, 87, 142, 453, 140, 101,
539	143, 87, 101, 44, 102, 103, 45, 102, 156, 104,
540	102, 103, 46, 102, 128, 104, 47, 157, 129, 48,
541	245, 49, 128, 132, 50, 164, 129, 133, 164, 51,
542	217, 52, 132, 53, 54, 56, 133, 142, 396, 130,
543
544	196, 143, 166, 196, 483, 267, 268, 130, 134, 57,
545	473, 167, 164, 105, 432, 164, 433, 134, 63, 105,
546	196, 465, 58, 196, 246, 59, 182, 185, 185, 182,
547	60, 185, 461, 277, 288, 64, 277, 288, 383, 61,
548	62, 66, 67, 474, 66, 182, 185, 185, 182, 473,
549	185, 384, 182, 185, 185, 182, 68, 185, 182, 185,
550	185, 182, 307, 185, 216, 307, 435, 216, 432, 69,
551	433, 217, 70, 182, 185, 185, 182, 71, 185, 218,
552	182, 185, 185, 182, 437, 185, 72, 73, 66, 67,
553	473, 66, 182, 185, 185, 182, 473, 185, 462, 182,
554
555	185, 185, 182, 68, 185, 461, 461, 194, 182, 185,
556	185, 182, 74, 185, 256, 341, 69, 256, 341, 70,
557	242, 243, 243, 242, 71, 257, 435, 337, 365, 75,
558	337, 365, 477, 72, 73, 76, 76, 76, 76, 76,
559	76, 77, 477, 76, 450, 76, 216, 76, 76, 216,
560	479, 461, 455, 217, 76, 76, 339, 194, 340, 366,
561	482, 76, 76, 76, 264, 264, 264, 264, 454, 244,
562	371, 365, 445, 371, 365, 274, 274, 274, 274, 285,
563	285, 285, 285, 265, 424, 76, 76, 76, 76, 76,
564	76, 76, 76, 77, 275, 76, 402, 76, 286, 76,
565
566	76, 214, 366, 410, 399, 383, 76, 76, 296, 296,
567	296, 296, 223, 76, 76, 76, 235, 400, 384, 290,
568	291, 291, 290, 407, 241, 242, 243, 243, 242, 391,
569	241, 242, 243, 243, 242, 383, 241, 76, 76, 76,
570	76, 76, 76, 76, 76, 79, 406, 76, 384, 76,
571	256, 76, 76, 256, 385, 301, 403, 297, 76, 76,
572	383, 257, 399, 402, 402, 76, 76, 76, 292, 305,
573	305, 305, 305, 384, 244, 400, 293, 294, 294, 293,
574	244, 241, 296, 296, 296, 296, 402, 249, 306, 76,
575	76, 76, 76, 76, 76, 76, 76, 79, 401, 76,
576
577	397, 76, 395, 76, 76, 264, 264, 264, 264, 261,
578	76, 76, 394, 274, 274, 274, 274, 76, 76, 76,
579	399, 393, 399, 277, 265, 295, 277, 392, 321, 388,
580	387, 297, 275, 400, 322, 400, 386, 385, 385, 385,
581	376, 76, 76, 88, 89, 90, 91, 89, 92, 93,
582	92, 94, 92, 92, 94, 92, 92, 92, 92, 92,
583	94, 92, 92, 92, 95, 95, 95, 95, 95, 92,
584	96, 92, 92, 92, 95, 95, 95, 95, 95, 95,
585	95, 95, 95, 95, 95, 95, 95, 95, 95, 95,
586	95, 95, 95, 97, 92, 107, 375, 364, 363, 108,
587
588	361, 316, 316, 316, 316, 109, 110, 282, 360, 111,
589	309, 309, 309, 309, 359, 310, 357, 271, 356, 112,
590	317, 113, 355, 318, 318, 318, 318, 365, 319, 265,
591	365, 285, 285, 285, 285, 114, 354, 334, 335, 335,
592	334, 273, 275, 115, 116, 107, 348, 343, 342, 108,
593	286, 326, 326, 326, 326, 109, 110, 333, 366, 111,
594	328, 328, 328, 328, 330, 329, 325, 324, 323, 112,
595	327, 113, 288, 320, 315, 288, 314, 331, 307, 286,
596	313, 307, 312, 332, 311, 114, 336, 290, 291, 291,
597	290, 284, 185, 115, 116, 118, 308, 304, 303, 119,
598
599	302, 305, 305, 305, 305, 120, 121, 347, 300, 122,
600	299, 290, 291, 291, 290, 298, 185, 435, 241, 123,
601	306, 124, 449, 293, 294, 294, 293, 240, 241, 293,
602	294, 294, 293, 289, 241, 450, 292, 287, 316, 316,
603	316, 316, 284, 125, 126, 118, 283, 337, 282, 119,
604	337, 326, 326, 326, 326, 120, 121, 317, 279, 122,
605	292, 344, 344, 344, 344, 227, 345, 227, 477, 123,
606	327, 124, 295, 481, 435, 432, 339, 433, 295, 449,
607	306, 227, 278, 276, 273, 272, 482, 271, 155, 266,
608	263, 262, 450, 125, 126, 180, 181, 181, 180, 182,
609
610	183, 182, 184, 182, 182, 184, 182, 182, 182, 182,
611	182, 184, 182, 182, 182, 185, 185, 185, 185, 185,
612	182, 186, 182, 182, 182, 185, 185, 185, 185, 185,
613	185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
614	185, 185, 185, 185, 187, 182, 188, 189, 189, 188,
615	188, 190, 188, 191, 188, 188, 191, 188, 188, 188,
616	188, 188, 191, 188, 188, 188, 189, 189, 189, 189,
617	189, 188, 192, 188, 188, 188, 189, 189, 189, 189,
618	189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
619	189, 189, 189, 189, 189, 193, 188, 227, 261, 260,
620
621	227, 227, 228, 227, 229, 227, 227, 229, 227, 227,
622	227, 227, 230, 229, 227, 227, 227, 228, 228, 228,
623	228, 228, 227, 227, 227, 227, 227, 228, 228, 228,
624	228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
625	228, 228, 228, 228, 228, 228, 227, 227, 247, 248,
626	248, 247, 247, 249, 247, 250, 247, 247, 250, 247,
627	247, 247, 247, 247, 250, 247, 247, 247, 248, 248,
628	248, 248, 248, 247, 251, 247, 247, 247, 248, 248,
629	248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
630	248, 248, 248, 248, 248, 248, 248, 247, 247, 309,
631
632	309, 309, 309, 259, 310, 206, 255, 253, 241, 241,
633	241, 240, 177, 176, 174, 238, 237, 236, 265, 349,
634	350, 350, 349, 349, 351, 349, 352, 349, 349, 352,
635	349, 349, 349, 349, 349, 352, 349, 349, 349, 350,
636	350, 350, 350, 350, 349, 353, 349, 349, 349, 350,
637	350, 350, 350, 350, 350, 350, 350, 350, 350, 350,
638	350, 350, 350, 350, 350, 350, 350, 350, 349, 349,
639	358, 358, 358, 358, 235, 319, 318, 318, 318, 318,
640	234, 319, 362, 362, 362, 362, 233, 329, 232, 317,
641	231, 328, 328, 328, 328, 275, 329, 334, 335, 335,
642
643	334, 327, 334, 335, 335, 334, 341, 226, 225, 341,
644	286, 365, 365, 365, 365, 344, 344, 344, 344, 224,
645	345, 223, 367, 358, 358, 358, 358, 222, 319, 221,
646	365, 365, 365, 365, 306, 374, 451, 451, 451, 451,
647	339, 367, 317, 220, 219, 215, 336, 404, 404, 404,
648	404, 336, 365, 365, 365, 365, 362, 362, 362, 362,
649	370, 329, 214, 367, 213, 212, 405, 211, 368, 408,
650	408, 408, 408, 210, 209, 327, 208, 413, 207, 370,
651	413, 369, 206, 414, 204, 452, 387, 203, 409, 199,
652	411, 411, 411, 411, 413, 198, 197, 413, 195, 179,
653
654	414, 370, 371, 365, 365, 371, 419, 177, 393, 412,
655	416, 413, 176, 367, 413, 174, 173, 414, 368, 404,
656	404, 404, 404, 417, 172, 422, 422, 422, 422, 395,
657	423, 369, 171, 372, 170, 169, 168, 165, 405, 163,
658	414, 162, 161, 160, 405, 159, 158, 155, 154, 153,
659	152, 370, 377, 378, 378, 377, 377, 379, 377, 380,
660	377, 377, 380, 377, 377, 377, 377, 377, 380, 377,
661	377, 377, 378, 378, 378, 378, 378, 377, 381, 377,
662	377, 377, 378, 378, 378, 378, 378, 378, 378, 378,
663	378, 378, 378, 378, 378, 378, 378, 378, 378, 378,
664
665	378, 377, 377, 389, 389, 151, 389, 389, 389, 389,
666	150, 389, 149, 389, 148, 389, 389, 408, 408, 408,
667	408, 391, 389, 389, 420, 420, 420, 420, 147, 389,
668	389, 389, 425, 425, 425, 425, 409, 146, 428, 428,
669	428, 428, 145, 421, 144, 427, 427, 427, 427, 484,
670	319, 426, 484, 389, 389, 389, 389, 429, 389, 389,
671	389, 389, 484, 389, 409, 389, 484, 389, 389, 484,
672	484, 484, 401, 484, 389, 389, 411, 411, 411, 411,
673	407, 389, 389, 389, 484, 484, 410, 484, 430, 430,
674	430, 430, 484, 329, 413, 412, 484, 413, 484, 484,
675
676	414, 451, 451, 451, 451, 389, 389, 412, 413, 484,
677	416, 413, 367, 484, 414, 413, 484, 484, 413, 435,
678	432, 414, 433, 417, 436, 435, 484, 432, 484, 433,
679	436, 416, 484, 466, 484, 413, 466, 437, 413, 467,
680	484, 414, 484, 437, 417, 413, 484, 432, 413, 433,
681	452, 414, 420, 420, 420, 420, 435, 432, 484, 433,
682	484, 436, 472, 484, 419, 438, 438, 438, 438, 484,
683	439, 421, 484, 484, 437, 422, 422, 422, 422, 484,
684	423, 484, 484, 484, 421, 484, 484, 484, 484, 484,
685	484, 484, 484, 484, 405, 440, 441, 441, 440, 440,
686
687	442, 440, 443, 440, 440, 443, 440, 440, 440, 440,
688	440, 443, 440, 440, 440, 441, 441, 441, 441, 441,
689	440, 444, 440, 440, 440, 441, 441, 441, 441, 441,
690	441, 441, 441, 441, 441, 441, 441, 441, 441, 441,
691	441, 441, 441, 441, 440, 440, 425, 425, 425, 425,
692	446, 446, 446, 446, 484, 319, 427, 427, 427, 427,
693	484, 319, 484, 484, 484, 426, 484, 484, 484, 426,
694	428, 428, 428, 428, 484, 409, 447, 447, 447, 447,
695	484, 329, 430, 430, 430, 430, 484, 329, 484, 429,
696	484, 438, 438, 438, 438, 429, 439, 484, 484, 484,
697
698	484, 412, 484, 484, 484, 484, 484, 484, 484, 484,
699	421, 456, 457, 457, 456, 456, 458, 456, 459, 456,
700	456, 459, 456, 456, 456, 456, 456, 459, 456, 456,
701	456, 457, 457, 457, 457, 457, 456, 460, 456, 456,
702	456, 457, 457, 457, 457, 457, 457, 457, 457, 457,
703	457, 457, 457, 457, 457, 457, 457, 457, 457, 457,
704	456, 456, 463, 463, 484, 463, 463, 463, 463, 484,
705	463, 484, 463, 484, 463, 463, 484, 484, 484, 484,
706	465, 463, 463, 484, 484, 484, 484, 484, 463, 463,
707	463, 446, 446, 446, 446, 484, 319, 447, 447, 447,
708
709	447, 484, 329, 435, 484, 484, 484, 484, 449, 484,
710	426, 466, 463, 463, 466, 484, 429, 467, 484, 435,
711	432, 450, 433, 466, 449, 484, 466, 469, 484, 467,
712	477, 432, 484, 433, 484, 481, 484, 450, 484, 484,
713	470, 463, 463, 484, 463, 463, 463, 463, 482, 463,
714	484, 463, 467, 463, 463, 484, 466, 484, 484, 466,
715	463, 463, 467, 484, 484, 484, 484, 463, 463, 463,
716	484, 484, 469, 484, 466, 484, 484, 466, 484, 484,
717	467, 484, 484, 484, 484, 470, 432, 484, 433, 484,
718	469, 463, 463, 466, 484, 484, 466, 477, 484, 467,
719
720	484, 484, 478, 470, 477, 432, 484, 433, 484, 478,
721	484, 484, 484, 466, 484, 479, 466, 484, 484, 467,
722	484, 484, 479, 466, 484, 432, 466, 433, 484, 467,
723	484, 484, 484, 484, 477, 432, 484, 433, 484, 478,
724	477, 484, 472, 484, 484, 481, 477, 432, 484, 433,
725	484, 481, 479, 484, 484, 484, 484, 484, 482, 484,
726	484, 484, 484, 484, 482, 40, 40, 40, 40, 40,
727	40, 40, 40, 40, 40, 40, 55, 55, 55, 55,
728	55, 55, 55, 55, 55, 55, 55, 65, 65, 65,
729	65, 65, 65, 65, 65, 65, 65, 65, 78, 78,
730
731	78, 78, 78, 78, 78, 78, 78, 78, 78, 80,
732	80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
733	81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
734	81, 98, 98, 98, 98, 98, 98, 98, 98, 98,
735	98, 98, 76, 76, 76, 76, 76, 76, 76, 76,
736	76, 76, 76, 106, 106, 106, 106, 106, 106, 106,
737	106, 106, 106, 106, 117, 117, 117, 117, 117, 117,
738	117, 117, 117, 117, 117, 127, 127, 127, 127, 127,
739	127, 127, 127, 127, 127, 127, 131, 131, 131, 131,
740	131, 131, 131, 131, 131, 131, 131, 135, 135, 135,
741
742	135, 135, 135, 135, 135, 135, 135, 135, 138, 138,
743	138, 138, 138, 138, 138, 138, 138, 138, 138, 141,
744	141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
745	175, 175, 175, 484, 484, 175, 175, 178, 178, 178,
746	484, 484, 178, 178, 205, 205, 484, 205, 205, 205,
747	205, 205, 205, 205, 205, 239, 239, 484, 239, 239,
748	239, 239, 239, 239, 239, 239, 252, 252, 484, 252,
749	252, 252, 252, 252, 252, 252, 252, 254, 254, 484,
750	254, 254, 254, 254, 254, 254, 254, 254, 258, 258,
751	484, 258, 258, 258, 258, 258, 258, 258, 258, 269,
752
753	269, 484, 269, 269, 269, 269, 269, 269, 269, 269,
754	270, 270, 484, 270, 270, 270, 270, 270, 270, 270,
755	270, 280, 280, 484, 280, 280, 280, 280, 280, 280,
756	280, 280, 281, 281, 484, 281, 281, 281, 281, 281,
757	281, 281, 281, 338, 484, 484, 484, 484, 338, 346,
758	484, 484, 484, 484, 346, 366, 366, 366, 484, 484,
759	366, 366, 484, 484, 366, 373, 484, 484, 484, 484,
760	373, 382, 484, 484, 484, 382, 390, 390, 484, 390,
761	390, 390, 390, 390, 390, 390, 390, 398, 484, 484,
762	484, 398, 389, 389, 484, 389, 389, 389, 389, 389,
763
764	389, 389, 389, 415, 484, 484, 484, 415, 415, 484,
765	484, 484, 415, 418, 484, 484, 484, 418, 418, 431,
766	484, 484, 484, 431, 431, 434, 484, 484, 484, 434,
767	434, 434, 434, 434, 434, 448, 448, 448, 448, 448,
768	464, 464, 484, 464, 464, 464, 464, 464, 464, 464,
769	464, 468, 484, 484, 484, 468, 468, 484, 484, 484,
770	468, 471, 484, 484, 484, 471, 471, 463, 463, 484,
771	463, 463, 463, 463, 463, 463, 463, 463, 475, 484,
772	484, 484, 475, 475, 476, 484, 484, 484, 476, 476,
773	476, 476, 476, 476, 480, 480, 480, 480, 480, 39,
774
775	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
776	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
777	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
778	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
779	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
780	484, 484
781	} ;
782
783	static yyconst short int yy_chk[2253] =
784	{ 0,
785	0, 1, 1, 1, 1, 0, 11, 11, 3, 11,
786	130, 15, 12, 12, 16, 12, 1, 11, 11, 1,
787	134, 11, 3, 12, 12, 1, 31, 12, 29, 1,
788	31, 130, 1, 30, 1, 3, 15, 1, 3, 16,
789	29, 134, 1, 3, 1, 30, 1, 1, 2, 2,
790	2, 2, 3, 3, 32, 11, 33, 525, 32, 15,
791	33, 12, 16, 2, 17, 17, 2, 17, 58, 17,
792	18, 18, 2, 18, 25, 18, 2, 58, 25, 2,
793	192, 2, 26, 27, 2, 66, 26, 27, 66, 2,
794	217, 2, 28, 2, 2, 4, 28, 34, 517, 25,
795
796	102, 34, 69, 102, 477, 217, 217, 26, 27, 4,
797	474, 69, 164, 17, 414, 164, 414, 28, 4, 18,
798	196, 465, 4, 196, 192, 4, 92, 92, 92, 92,
799	4, 92, 462, 225, 237, 4, 225, 237, 346, 4,
800	4, 5, 5, 460, 5, 94, 94, 94, 94, 459,
801	94, 346, 95, 95, 95, 95, 5, 95, 96, 96,
802	96, 96, 262, 96, 155, 262, 437, 155, 467, 5,
803	467, 155, 5, 182, 182, 182, 182, 5, 182, 155,
804	184, 184, 184, 184, 437, 184, 5, 5, 6, 6,
805	457, 6, 185, 185, 185, 185, 456, 185, 444, 194,
806
807	194, 194, 194, 6, 194, 443, 441, 96, 186, 186,
808	186, 186, 6, 186, 207, 300, 6, 207, 300, 6,
809	190, 190, 190, 190, 6, 207, 450, 299, 366, 6,
810	299, 366, 479, 6, 6, 7, 7, 7, 7, 7,
811	7, 7, 482, 7, 450, 7, 216, 7, 7, 216,
812	479, 440, 435, 216, 7, 7, 299, 186, 299, 366,
813	482, 7, 7, 7, 214, 214, 214, 214, 433, 190,
814	371, 368, 424, 371, 368, 223, 223, 223, 223, 235,
815	235, 235, 235, 214, 406, 7, 7, 8, 8, 8,
816	8, 8, 8, 8, 223, 8, 403, 8, 235, 8,
817
818	8, 214, 368, 394, 373, 382, 8, 8, 296, 296,
819	296, 296, 223, 8, 8, 8, 235, 373, 382, 241,
820	241, 241, 241, 392, 241, 242, 242, 242, 242, 391,
821	242, 243, 243, 243, 243, 383, 243, 8, 8, 9,
822	9, 9, 9, 9, 9, 9, 388, 9, 383, 9,
823	256, 9, 9, 256, 386, 256, 381, 296, 9, 9,
824	384, 256, 398, 380, 378, 9, 9, 9, 241, 261,
825	261, 261, 261, 384, 242, 398, 245, 245, 245, 245,
826	243, 245, 249, 249, 249, 249, 377, 249, 261, 9,
827	9, 10, 10, 10, 10, 10, 10, 10, 375, 10,
828
829	367, 10, 363, 10, 10, 264, 264, 264, 264, 261,
830	10, 10, 361, 274, 274, 274, 274, 10, 10, 10,
831	399, 359, 400, 277, 264, 245, 277, 357, 277, 355,
832	354, 249, 274, 399, 277, 400, 353, 352, 350, 349,
833	343, 10, 10, 13, 13, 13, 13, 13, 13, 13,
834	13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
835	13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
836	13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
837	13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
838	13, 13, 13, 13, 13, 19, 342, 332, 330, 19,
839
840	325, 273, 273, 273, 273, 19, 19, 324, 322, 19,
841	265, 265, 265, 265, 320, 265, 315, 314, 313, 19,
842	273, 19, 312, 275, 275, 275, 275, 369, 275, 265,
843	369, 285, 285, 285, 285, 19, 311, 298, 298, 298,
844	298, 273, 275, 19, 19, 20, 308, 304, 303, 20,
845	285, 284, 284, 284, 284, 20, 20, 289, 369, 20,
846	286, 286, 286, 286, 287, 286, 283, 282, 278, 20,
847	284, 20, 288, 276, 272, 288, 271, 288, 307, 286,
848	268, 307, 267, 288, 266, 20, 298, 290, 290, 290,
849	290, 284, 290, 20, 20, 23, 263, 260, 259, 23,
850
851	257, 305, 305, 305, 305, 23, 23, 307, 255, 23,
852	253, 291, 291, 291, 291, 251, 291, 449, 246, 23,
853	305, 23, 449, 293, 293, 293, 293, 240, 293, 294,
854	294, 294, 294, 238, 294, 449, 290, 236, 316, 316,
855	316, 316, 234, 23, 23, 24, 233, 337, 232, 24,
856	337, 326, 326, 326, 326, 24, 24, 316, 230, 24,
857	291, 306, 306, 306, 306, 229, 306, 228, 481, 24,
858	326, 24, 293, 481, 431, 431, 337, 431, 294, 431,
859	306, 227, 226, 224, 222, 221, 481, 220, 218, 215,
860	213, 212, 431, 24, 24, 89, 89, 89, 89, 89,
861
862	89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
863	89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
864	89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
865	89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
866	89, 89, 89, 89, 89, 89, 93, 93, 93, 93,
867	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
868	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
869	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
870	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
871	93, 93, 93, 93, 93, 93, 93, 165, 211, 210,
872
873	165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
874	165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
875	165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
876	165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
877	165, 165, 165, 165, 165, 165, 165, 165, 193, 193,
878	193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
879	193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
880	193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
881	193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
882	193, 193, 193, 193, 193, 193, 193, 193, 193, 309,
883
884	309, 309, 309, 209, 309, 206, 204, 198, 191, 189,
885	188, 179, 178, 177, 175, 173, 172, 171, 309, 310,
886	310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
887	310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
888	310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
889	310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
890	310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
891	317, 317, 317, 317, 170, 317, 318, 318, 318, 318,
892	169, 318, 327, 327, 327, 327, 168, 327, 167, 317,
893	166, 328, 328, 328, 328, 318, 328, 334, 334, 334,
894
895	334, 327, 335, 335, 335, 335, 341, 163, 162, 341,
896	328, 339, 339, 339, 339, 344, 344, 344, 344, 161,
897	344, 160, 339, 358, 358, 358, 358, 159, 358, 158,
898	365, 365, 365, 365, 344, 341, 451, 451, 451, 451,
899	339, 365, 358, 157, 156, 154, 334, 387, 387, 387,
900	387, 335, 338, 338, 338, 338, 362, 362, 362, 362,
901	339, 362, 153, 338, 152, 151, 387, 150, 338, 393,
902	393, 393, 393, 149, 148, 362, 147, 397, 146, 365,
903	397, 338, 145, 397, 144, 451, 387, 137, 393, 122,
904	395, 395, 395, 395, 396, 114, 111, 396, 100, 86,
905
906	396, 338, 340, 340, 340, 340, 397, 80, 393, 395,
907	396, 413, 79, 340, 413, 78, 75, 413, 340, 404,
908	404, 404, 404, 396, 74, 405, 405, 405, 405, 395,
909	405, 340, 73, 340, 72, 71, 70, 68, 404, 64,
910	413, 63, 62, 61, 405, 60, 59, 57, 54, 53,
911	52, 340, 345, 345, 345, 345, 345, 345, 345, 345,
912	345, 345, 345, 345, 345, 345, 345, 345, 345, 345,
913	345, 345, 345, 345, 345, 345, 345, 345, 345, 345,
914	345, 345, 345, 345, 345, 345, 345, 345, 345, 345,
915	345, 345, 345, 345, 345, 345, 345, 345, 345, 345,
916
917	345, 345, 345, 356, 356, 51, 356, 356, 356, 356,
918	50, 356, 49, 356, 48, 356, 356, 408, 408, 408,
919	408, 356, 356, 356, 401, 401, 401, 401, 47, 356,
920	356, 356, 407, 407, 407, 407, 408, 46, 410, 410,
921	410, 410, 44, 401, 41, 409, 409, 409, 409, 39,
922	409, 407, 0, 356, 356, 390, 390, 410, 390, 390,
923	390, 390, 0, 390, 409, 390, 0, 390, 390, 0,
924	0, 0, 401, 0, 390, 390, 411, 411, 411, 411,
925	407, 390, 390, 390, 0, 0, 410, 0, 412, 412,
926	412, 412, 0, 412, 416, 411, 0, 416, 0, 0,
927
928	416, 432, 432, 432, 432, 390, 390, 412, 415, 0,
929	416, 415, 432, 0, 415, 417, 0, 0, 417, 415,
930	415, 417, 415, 416, 415, 436, 436, 417, 436, 417,
931	436, 417, 0, 454, 0, 419, 454, 415, 419, 454,
932	0, 419, 0, 436, 417, 418, 0, 419, 418, 419,
933	432, 418, 420, 420, 420, 420, 418, 418, 0, 418,
934	0, 418, 454, 0, 419, 421, 421, 421, 421, 0,
935	421, 420, 0, 0, 418, 422, 422, 422, 422, 0,
936	422, 0, 0, 0, 421, 0, 0, 0, 0, 0,
937	0, 0, 0, 0, 422, 423, 423, 423, 423, 423,
938
939	423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
940	423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
941	423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
942	423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
943	423, 423, 423, 423, 423, 423, 425, 425, 425, 425,
944	426, 426, 426, 426, 0, 426, 427, 427, 427, 427,
945	0, 427, 0, 0, 0, 425, 0, 0, 0, 426,
946	428, 428, 428, 428, 0, 427, 429, 429, 429, 429,
947	0, 429, 430, 430, 430, 430, 0, 430, 0, 428,
948	0, 438, 438, 438, 438, 429, 438, 0, 0, 0,
949
950	0, 430, 0, 0, 0, 0, 0, 0, 0, 0,
951	438, 439, 439, 439, 439, 439, 439, 439, 439, 439,
952	439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
953	439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
954	439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
955	439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
956	439, 439, 445, 445, 0, 445, 445, 445, 445, 0,
957	445, 0, 445, 0, 445, 445, 0, 0, 0, 0,
958	445, 445, 445, 0, 0, 0, 0, 0, 445, 445,
959	445, 446, 446, 446, 446, 0, 446, 447, 447, 447,
960
961	447, 0, 447, 448, 448, 0, 448, 0, 448, 0,
962	446, 453, 445, 445, 453, 0, 447, 453, 0, 455,
963	455, 448, 455, 466, 455, 0, 466, 453, 0, 466,
964	475, 475, 0, 475, 0, 475, 0, 455, 0, 0,
965	453, 464, 464, 0, 464, 464, 464, 464, 475, 464,
966	0, 464, 466, 464, 464, 0, 469, 0, 0, 469,
967	464, 464, 469, 0, 0, 0, 0, 464, 464, 464,
968	0, 0, 469, 0, 470, 0, 0, 470, 0, 0,
969	470, 0, 0, 0, 0, 469, 470, 0, 470, 0,
970	470, 464, 464, 468, 0, 0, 468, 478, 478, 468,
971
972	478, 0, 478, 470, 468, 468, 0, 468, 0, 468,
973	0, 0, 0, 472, 0, 478, 472, 0, 0, 472,
974	0, 0, 468, 471, 0, 472, 471, 472, 0, 471,
975	0, 0, 0, 0, 471, 471, 0, 471, 0, 471,
976	480, 480, 472, 480, 0, 480, 483, 483, 0, 483,
977	0, 483, 471, 0, 0, 0, 0, 0, 480, 0,
978	0, 0, 0, 0, 483, 485, 485, 485, 485, 485,
979	485, 485, 485, 485, 485, 485, 486, 486, 486, 486,
980	486, 486, 486, 486, 486, 486, 486, 487, 487, 487,
981	487, 487, 487, 487, 487, 487, 487, 487, 488, 488,
982
983	488, 488, 488, 488, 488, 488, 488, 488, 488, 489,
984	489, 489, 489, 489, 489, 489, 489, 489, 489, 489,
985	490, 490, 490, 490, 490, 490, 490, 490, 490, 490,
986	490, 491, 491, 491, 491, 491, 491, 491, 491, 491,
987	491, 491, 492, 492, 492, 492, 492, 492, 492, 492,
988	492, 492, 492, 493, 493, 493, 493, 493, 493, 493,
989	493, 493, 493, 493, 494, 494, 494, 494, 494, 494,
990	494, 494, 494, 494, 494, 495, 495, 495, 495, 495,
991	495, 495, 495, 495, 495, 495, 496, 496, 496, 496,
992	496, 496, 496, 496, 496, 496, 496, 497, 497, 497,
993
994	497, 497, 497, 497, 497, 497, 497, 497, 498, 498,
995	498, 498, 498, 498, 498, 498, 498, 498, 498, 499,
996	499, 499, 499, 499, 499, 499, 499, 499, 499, 499,
997	500, 500, 500, 0, 0, 500, 500, 501, 501, 501,
998	0, 0, 501, 501, 502, 502, 0, 502, 502, 502,
999	502, 502, 502, 502, 502, 503, 503, 0, 503, 503,
1000	503, 503, 503, 503, 503, 503, 504, 504, 0, 504,
1001	504, 504, 504, 504, 504, 504, 504, 505, 505, 0,
1002	505, 505, 505, 505, 505, 505, 505, 505, 506, 506,
1003	0, 506, 506, 506, 506, 506, 506, 506, 506, 507,
1004
1005	507, 0, 507, 507, 507, 507, 507, 507, 507, 507,
1006	508, 508, 0, 508, 508, 508, 508, 508, 508, 508,
1007	508, 509, 509, 0, 509, 509, 509, 509, 509, 509,
1008	509, 509, 510, 510, 0, 510, 510, 510, 510, 510,
1009	510, 510, 510, 511, 0, 0, 0, 0, 511, 512,
1010	0, 0, 0, 0, 512, 513, 513, 513, 0, 0,
1011	513, 513, 0, 0, 513, 514, 0, 0, 0, 0,
1012	514, 515, 0, 0, 0, 515, 516, 516, 0, 516,
1013	516, 516, 516, 516, 516, 516, 516, 518, 0, 0,
1014	0, 518, 519, 519, 0, 519, 519, 519, 519, 519,
1015
1016	519, 519, 519, 520, 0, 0, 0, 520, 520, 0,
1017	0, 0, 520, 521, 0, 0, 0, 521, 521, 522,
1018	0, 0, 0, 522, 522, 523, 0, 0, 0, 523,
1019	523, 523, 523, 523, 523, 524, 524, 524, 524, 524,
1020	526, 526, 0, 526, 526, 526, 526, 526, 526, 526,
1021	526, 527, 0, 0, 0, 527, 527, 0, 0, 0,
1022	527, 528, 0, 0, 0, 528, 528, 529, 529, 0,
1023	529, 529, 529, 529, 529, 529, 529, 529, 530, 0,
1024	0, 0, 530, 530, 531, 0, 0, 0, 531, 531,
1025	531, 531, 531, 531, 532, 532, 532, 532, 532, 484,
1026
1027	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
1028	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
1029	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
1030	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
1031	484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
1032	484, 484
1033	} ;
1034
1035	static yy_state_type yy_last_accepting_state;
1036	static char *yy_last_accepting_cpos;
1037
1038	/* The intent behind this definition is that it'll catch
1039	* any uses of REJECT which flex missed.
1040	*/
1041	#define REJECT reject_used_but_not_detected
1042	static int yy_more_flag = 0;
1043	static int yy_more_len = 0;
1044	#define yymore() (yy_more_flag = 1)
1045	#define YY_MORE_ADJ yy_more_len
1046	#define YY_RESTORE_YY_MORE_OFFSET
1047	char *yytext;
1048	#line 1 "libparse.l"
1049	#define INITIAL 0
1050	#line 2 "libparse.l"
1051	/****************************************
1052	* Computer Algebra System SINGULAR *
1053	****************************************/
1054	/* $Id$ */
1055	#include <stdio.h>
1056	#include <string.h>
1057	#include <stdlib.h>
1058	#include <ctype.h>
1059	#include "config.h"
1060	#include <kernel/mod2.h>
1061	#ifdef STANDALONE_PARSER
1062	#include <Singular/utils.h>
1063
1064	# ifdef HAVE_FACTORY
1065	int initializeGMP(){ return 1; } // NEEDED FOR MAIN APP. LINKING!!!
1066	int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
1067	# endif
1068
1069	#define HAVE_LIBPARSER
1070	#define YYLPDEBUG 1
1071	#define myfread fread
1072	#else
1073	#include <Singular/subexpr.h>
1074	#include <Singular/grammar.h>
1075	#include <Singular/ipshell.h>
1076	#include <Singular/ipid.h>
1077	#include <Singular/tok.h>
1078	#include <misc/options.h>
1079	#include <kernel/febase.h>
1080	#include <omalloc/omalloc.h>
1081	#endif
1082	#include <Singular/libparse.h>
1083
1084	#ifdef HAVE_LIBPARSER
1085	#define YY_SKIP_YYWRAP
1086
1087	typedef enum { LP_NONE, LP_INFO, LP_CATEGORY, LP_URL, LP_VERSION} lib_cmds;
1088
1089	int libread(FILE* f, char* buf, int max_size);
1090	int current_pos(int i);
1091	void print_version(lp_modes mode, char *p);
1092	void copy_string(lp_modes mode);
1093	extern void piCleanUp(procinfov pi);
1094	void make_version(char *p, int what);
1095
1096	int brace1 = 0; /* { } */
1097	int brace2 = 0; /* ( ) */
1098	int brace3 = 0; /* [ ] */
1099	int quote = 0; /* " */
1100	int offset = 0;
1101	BOOLEAN p_static = FALSE;
1102	int old_state = 0;
1103	lib_cmds last_cmd = LP_NONE;
1104
1105	char libnamebuf[128];
1106	char *text_buffer=NULL;
1107	long string_start;
1108
1109	char *yylp_buffer_start;
1110	int yylplineno = 1;
1111	int lpverbose = 0, check = 0;
1112	int texinfo_out = 0;
1113	int found_info=0,
1114	found_cat=0,
1115	found_version=0,
1116	found_oldhelp = 0,
1117	found_proc_in_proc = 0;
1118
1119	const char *yylp_errlist[]= {
1120	"",
1121	"missing close bracket ')' for proc definition in line %d.", /* 1 */
1122	"missing close bracket ')' for procbody in line %d.", /* 2 */
1123	"missing close bracket ']' for procbody in line %d.", /* 3 */
1124	"too many ')' closed brackets in line %d.", /* 4 */
1125	"too many ']' closed brackets in line %d.", /* 5 */
1126	"missing close bracket ')' for example in line %d.", /* 6 */
1127	"missing close bracket ']' for example in line %d.", /* 7 */
1128	"cannot assign character '%c' in line %d to any group.", /* 8 */
1129	"there must be a quote missing somewhere before line %d.", /* 9 */
1130	"missing close bracket '}' at end of library in line %d.", /* 10 */
1131	"missing close bracket ')' at end of library in line %d.", /* 11 */
1132	"missing close bracket ']' at end of library in line %d.", /* 12 */
1133	NULL
1134	};
1135	int yylp_errno = 0;
1136
1137	#ifdef STANDALONE_PARSER
1138	procinfov pi;
1139	int category_out = 0;
1140	void printpi(procinfov pi);
1141	void pi_clear(procinfov pi);
1142	extern "C" {
1143	int yylpwrap();
1144	}
1145	void main_init(int argc, char *argv[]);
1146	void main_result(char *libname);
1147	#else /* STANDALONE_PARSER */
1148	idhdl h0;
1149	idhdl h_top;
1150	#define pi IDPROC(h0)
1151	extern "C"
1152	{
1153	int yylpwrap();
1154	}
1155	extern libstackv library_stack;
1156	#endif /* STANDALONE_PARSER */
1157
1158	static unsigned long help_chksum;
1159
1160	#define SET_DEF_END(mode, pi, p) \
1161	if ( mode == LOAD_LIB) pi->data.s.def_end = p;
1162	#define SET_HELP_START(mode, pi, p) \
1163	if ( mode == LOAD_LIB) {pi->data.s.help_start = p; help_chksum = 0;}
1164	#define SET_HELP_END(mode, pi, p) \
1165	if ( mode == LOAD_LIB) {pi->data.s.help_end = p; \
1166	pi->data.s.help_chksum = help_chksum;}
1167
1168	#define SET_BODY_START(mode, pi, l, p) \
1169	if ( mode == LOAD_LIB) \
1170	{ \
1171	pi->data.s.body_lineno = l; \
1172	pi->data.s.body_start = p; \
1173	}
1174	#define SET_BODY_END(mode, pi, p) \
1175	if ( mode == LOAD_LIB) \
1176	{ \
1177	pi->data.s.body_end = p-1; \
1178	pi->data.s.proc_end = p-1; \
1179	}
1180
1181	#define SET_EXAMPLE_START(mode, pi, l, p) \
1182	if ( mode == LOAD_LIB) \
1183	{ \
1184	pi->data.s.example_lineno = l; \
1185	pi->data.s.example_start = p; \
1186	}
1187	#define SET_PROC_END(mode, pi, p) \
1188	if ( mode == LOAD_LIB) \
1189	{ \
1190	pi->data.s.proc_end = p-1; \
1191	if(pi->data.s.body_end==0) \
1192	pi->data.s.body_end = p-1; \
1193	}
1194
1195	#define ROTATE_RIGHT(c) if ((c) & 01) (c) = ((c) >>1) + 0x8000; else (c) >>= 1;
1196	#define IncrCheckSum(c) \
1197	do \
1198	{ \
1199	ROTATE_RIGHT(help_chksum); \
1200	help_chksum += c; \
1201	help_chksum &= 0xffff; \
1202	} \
1203	while(0)
1204
1205	#undef YY_DECL
1206	#define YY_DECL int yylex(char newlib, char libfile, \
1207	lib_style_types *lib_style, \
1208	idhdl pl, BOOLEAN autoexport, lp_modes mode)
1209	#undef YY_INPUT
1210	#define YY_INPUT(buf,result,max_size) \
1211	if ( ((result = libread( (yyin), (char *) buf, max_size )) < 0 ) \
1212	&& ferror( yyin ) ) \
1213	YY_FATAL_ERROR( "read in flex scanner failed" );
1214
1215	#define YY_USER_INIT { \
1216	BEGIN(header); \
1217	yylplineno = 1; \
1218	yylp_errno = 0; \
1219	*lib_style = OLD_LIBSTYLE; \
1220	strcpy(libnamebuf,"(unknown version)"); \
1221	}
1222
1223	#if 0
1224	<pbody>proc[ \t]+{name} {
1225	printf("MISSING: PROC-cmd found. ERROR!\n"); }
1226	<pbody>example[ \t]*\n {
1227	yylplineno++;
1228	printf("MISSING: EXAMPLE-cmd found. ERROR!\n"); }
1229	info=+"\"" {
1230	#endif
1231
1232	/* %start START */
1233	#define header 1
1234
1235	#define help 2
1236
1237	#define libcmd 3
1238
1239	#define libcmd2 4
1240
1241	#define pdef 5
1242
1243	#define phead 6
1244
1245	#define poldhelp 7
1246
1247	#define phelp 8
1248
1249	#define pbody 9
1250
1251	#define pstr 10
1252
1253	#define pexample 11
1254
1255	#define pestr 12
1256
1257	#define string 13
1258
1259	#define comment 14
1260
1261	#define info 15
1262
1263	#define category 16
1264
1265	#define url 17
1266
1267	#define version 18
1268
1269
1270	/* Macros after this point can all be overridden by user definitions in
1271	* section 1.
1272	*/
1273
1274	#ifndef YY_SKIP_YYWRAP
1275	#ifdef __cplusplus
1276	extern "C" int yywrap YY_PROTO(( void ));
1277	#else
1278	extern int yywrap YY_PROTO(( void ));
1279	#endif
1280	#endif
1281
1282	#ifndef YY_NO_UNPUT
1283	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1284	#endif
1285
1286	#ifndef yytext_ptr
1287	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
1288	#endif
1289
1290	#ifdef YY_NEED_STRLEN
1291	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1292	#endif
1293
1294	#ifndef YY_NO_INPUT
1295	#ifdef __cplusplus
1296	static int yyinput YY_PROTO(( void ));
1297	#else
1298	static int input YY_PROTO(( void ));
1299	#endif
1300	#endif
1301
1302	#if YY_STACK_USED
1303	static int yy_start_stack_ptr = 0;
1304	static int yy_start_stack_depth = 0;
1305	static int *yy_start_stack = 0;
1306	#ifndef YY_NO_PUSH_STATE
1307	static void yy_push_state YY_PROTO(( int new_state ));
1308	#endif
1309	#ifndef YY_NO_POP_STATE
1310	static void yy_pop_state YY_PROTO(( void ));
1311	#endif
1312	#ifndef YY_NO_TOP_STATE
1313	static int yy_top_state YY_PROTO(( void ));
1314	#endif
1315
1316	#else
1317	#define YY_NO_PUSH_STATE 1
1318	#define YY_NO_POP_STATE 1
1319	#define YY_NO_TOP_STATE 1
1320	#endif
1321
1322	#ifdef YY_MALLOC_DECL
1323	YY_MALLOC_DECL
1324	#else
1325	#if __STDC__
1326	#ifndef __cplusplus
1327	#include <stdlib.h>
1328	#endif
1329	#else
1330	/* Just try to get by without declaring the routines. This will fail
1331	* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1332	* or sizeof(void*) != sizeof(int).
1333	*/
1334	#endif
1335	#endif
1336
1337	/* Amount of stuff to slurp up with each read. */
1338	#ifndef YY_READ_BUF_SIZE
1339	#define YY_READ_BUF_SIZE 8192
1340	#endif
1341
1342	/* Copy whatever the last rule matched to the standard output. */
1343
1344	#ifndef ECHO
1345	/* This used to be an fputs(), but since the string might contain NUL's,
1346	* we now use fwrite().
1347	*/
1348	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1349	#endif
1350
1351	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1352	* is returned in "result".
1353	*/
1354	#ifndef YY_INPUT
1355	#define YY_INPUT(buf,result,max_size) \
1356	if ( yy_current_buffer->yy_is_interactive ) \
1357	{ \
1358	int c = '*', n; \
1359	for ( n = 0; n < max_size && \
1360	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1361	buf[n] = (char) c; \
1362	if ( c == '\n' ) \
1363	buf[n++] = (char) c; \
1364	if ( c == EOF && ferror( yyin ) ) \
1365	YY_FATAL_ERROR( "input in flex scanner failed" ); \
1366	result = n; \
1367	} \
1368	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1369	&& ferror( yyin ) ) \
1370	YY_FATAL_ERROR( "input in flex scanner failed" );
1371	#endif
1372
1373	/* No semi-colon after return; correct usage is to write "yyterminate();" -
1374	* we don't want an extra ';' after the "return" because that will cause
1375	* some compilers to complain about unreachable statements.
1376	*/
1377	#ifndef yyterminate
1378	#define yyterminate() return YY_NULL
1379	#endif
1380
1381	/* Number of entries by which start-condition stack grows. */
1382	#ifndef YY_START_STACK_INCR
1383	#define YY_START_STACK_INCR 25
1384	#endif
1385
1386	/* Report a fatal error. */
1387	#ifndef YY_FATAL_ERROR
1388	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1389	#endif
1390
1391	/* Default declaration of generated scanner - a define so the user can
1392	* easily add parameters.
1393	*/
1394	#ifndef YY_DECL
1395	#define YY_DECL int yylex YY_PROTO(( void ))
1396	#endif
1397
1398	/* Code executed at the beginning of each rule, after yytext and yyleng
1399	* have been set up.
1400	*/
1401	#ifndef YY_USER_ACTION
1402	#define YY_USER_ACTION
1403	#endif
1404
1405	/* Code executed at the end of each rule. */
1406	#ifndef YY_BREAK
1407	#define YY_BREAK break;
1408	#endif
1409
1410	#define YY_RULE_SETUP \
1411	if ( yyleng > 0 ) \
1412	yy_current_buffer->yy_at_bol = \
1413	(yytext[yyleng - 1] == '\n'); \
1414	YY_USER_ACTION
1415
1416	YY_DECL
1417	{
1418	register yy_state_type yy_current_state;
1419	register char yy_cp = NULL, yy_bp = NULL;
1420	register int yy_act;
1421
1422	#line 228 "libparse.l"
1423
1424
1425	if ( yy_init )
1426	{
1427	yy_init = 0;
1428
1429	#ifdef YY_USER_INIT
1430	YY_USER_INIT;
1431	#endif
1432
1433	if ( ! yy_start )
1434	yy_start = 1; /* first start state */
1435
1436	if ( ! yyin )
1437	yyin = stdin;
1438
1439	if ( ! yyout )
1440	yyout = stdout;
1441
1442	if ( ! yy_current_buffer )
1443	yy_current_buffer =
1444	yy_create_buffer( yyin, YY_BUF_SIZE );
1445
1446	yy_load_buffer_state();
1447	}
1448
1449	while ( 1 ) /* loops until end-of-file is reached */
1450	{
1451	yy_more_len = 0;
1452	if ( yy_more_flag )
1453	{
1454	yy_more_len = yy_c_buf_p - yytext_ptr;
1455	yy_more_flag = 0;
1456	}
1457	yy_cp = yy_c_buf_p;
1458
1459	/* Support of yytext. */
1460	*yy_cp = yy_hold_char;
1461
1462	/* yy_bp points to the position in yy_ch_buf of the start of
1463	* the current run.
1464	*/
1465	yy_bp = yy_cp;
1466
1467	yy_current_state = yy_start;
1468	yy_current_state += YY_AT_BOL();
1469	yy_match:
1470	do
1471	{
1472	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1473	if ( yy_accept[yy_current_state] )
1474	{
1475	yy_last_accepting_state = yy_current_state;
1476	yy_last_accepting_cpos = yy_cp;
1477	}
1478	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1479	{
1480	yy_current_state = (int) yy_def[yy_current_state];
1481	if ( yy_current_state >= 485 )
1482	yy_c = yy_meta[(unsigned int) yy_c];
1483	}
1484	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1485	++yy_cp;
1486	}
1487	while ( yy_base[yy_current_state] != 2200 );
1488
1489	yy_find_action:
1490	yy_act = yy_accept[yy_current_state];
1491	if ( yy_act == 0 )
1492	{ /* have to back up */
1493	yy_cp = yy_last_accepting_cpos;
1494	yy_current_state = yy_last_accepting_state;
1495	yy_act = yy_accept[yy_current_state];
1496	}
1497
1498	YY_DO_BEFORE_ACTION;
1499
1500
1501	do_action: /* This label is used only to access EOF actions. */
1502
1503
1504	switch ( yy_act )
1505	{ /* beginning of action switch */
1506	case 0: /* must back up */
1507	/* undo the effects of YY_DO_BEFORE_ACTION */
1508	*yy_cp = yy_hold_char;
1509	yy_cp = yy_last_accepting_cpos;
1510	yy_current_state = yy_last_accepting_state;
1511	goto yy_find_action;
1512
1513	case 1:
1514	YY_RULE_SETUP
1515	#line 229 "libparse.l"
1516	{ }
1517	YY_BREAK
1518	case 2:
1519	YY_RULE_SETUP
1520	#line 230 "libparse.l"
1521	{ old_state = YYSTATE; BEGIN(comment); }
1522	YY_BREAK
1523	case 3:
1524	YY_RULE_SETUP
1525	#line 232 "libparse.l"
1526	{
1527	yyless(4); old_state = YYSTATE; BEGIN(info);
1528	}
1529	YY_BREAK
1530	case 4:
1531	YY_RULE_SETUP
1532	#line 235 "libparse.l"
1533	{
1534	yyless(8); old_state = YYSTATE; BEGIN(category);
1535	}
1536	YY_BREAK
1537	case 5:
1538	YY_RULE_SETUP
1539	#line 238 "libparse.l"
1540	{
1541	if ( mode != GET_INFO )
1542	{
1543	#ifdef STANDALONE_PARSER
1544	if (texinfo_out)
1545	{
1546	char *c = yytext;
1547	printf("$url = \"");
1548	while ((c != '\0') && (c != '"')) c++;
1549	c++;
1550	while ((c != '\0') && (c != '"'))
1551	{
1552	if (c != '\r') putchar(c);
1553	c++;
1554	}
1555	printf("\";\n");
1556	}
1557	#endif
1558	}
1559	}
1560	YY_BREAK
1561	case 6:
1562	YY_RULE_SETUP
1563	#line 259 "libparse.l"
1564	{
1565	found_version++;
1566	if ( mode != GET_INFO )
1567	{
1568	make_version(yytext,1);
1569	#ifdef STANDALONE_PARSER
1570	if (texinfo_out)
1571	{
1572	char *c = libnamebuf;
1573	printf("$version = \"");
1574	while (*c != '\0')
1575	{
1576	if (c == '$' \|\| c == '@') putchar('\\');
1577	if (c != '\r') putchar(c);
1578	if (*c == '\\')
1579	{
1580	c++;
1581	if (*c != '"') putchar('\\');
1582	}
1583	else
1584	c++;
1585	}
1586	printf("\";\n");
1587	}
1588	else if (!category_out)
1589	printf("Version:%s;\n", libnamebuf);
1590	#else
1591	if (text_buffer!=NULL) omFree((ADDRESS)text_buffer);
1592	text_buffer = omStrDup(libnamebuf);
1593	omMarkAsStaticAddr(text_buffer);
1594	#endif
1595	}
1596	}
1597	YY_BREAK
1598	case 7:
1599	YY_RULE_SETUP
1600	#line 293 "libparse.l"
1601	{ p_static=TRUE; }
1602	YY_BREAK
1603	case 8:
1604	YY_RULE_SETUP
1605	#line 295 "libparse.l"
1606	{
1607	char proc[256];
1608	BEGIN(pdef);
1609	found_proc_in_proc = 0;
1610	proc[0]='\0';
1611	sscanf( yytext, "%*[^p]proc %s", proc);
1612	if(strlen(proc)<1) sscanf( yytext, "proc %s", proc);
1613	#if YYLPDEBUG > 1
1614	printf("Newlib:%s\n", newlib);
1615	#endif
1616	#ifdef STANDALONE_PARSER
1617	if ( pi != NULL )
1618	{
1619	printpi(pi);
1620	pi_clear(pi);
1621	}
1622	#ifdef STANDALONE_PARSER
1623	pi = (procinfo *)malloc(sizeof(procinfo));
1624	#else
1625	pi = (procinfo *)omAlloc(sizeof(procinfo));
1626	#endif
1627	iiInitSingularProcinfo(pi, newlib, proc, yylplineno,
1628	current_pos(0), p_static);
1629	#else /STANDALONE_PARSER/
1630	if( mode == LOAD_LIB)
1631	{
1632	h0 = enterid( proc, 0 /myynest/, PROC_CMD,
1633	&(IDPACKAGE(pl)->idroot), TRUE, !p_static);
1634	if (h0==NULL) return(1);
1635	if((!p_static) && autoexport)
1636	{
1637	package save=currPack;
1638	currPack=basePack;
1639	h_top = enterid( proc, 0 /myynest/, PROC_CMD,
1640	&(basePack->idroot), FALSE );
1641	currPack=save;
1642	if (h_top==NULL) return(1);
1643	}
1644	/* omCheckAddr(IDID(h0)); */
1645	if (h0!=NULL)
1646	{
1647	iiInitSingularProcinfo(IDPROC(h0), newlib, proc,
1648	yylplineno, current_pos(0),p_static);
1649	if ((!p_static) && (h_top != NULL) && autoexport)
1650	{
1651	if(IDPROC(h_top)!=NULL) piCleanUp((procinfo *)IDPROC(h_top));
1652	IDPROC(h_top)=IDPROC(h0);
1653	IDPROC(h_top)->ref++;
1654	}
1655	IDPROC(h0)->pack=IDPACKAGE(pl);
1656	if (BVERBOSE(V_LOAD_PROC))
1657	Warn( " proc '%s' registered", proc );
1658	}
1659	#endif /STANDALONE_PARSER/
1660	SET_DEF_END(mode, pi, current_pos(yyleng+1));
1661	#if YYLPDEBUG
1662	if(lpverbose)
1663	{
1664	printf("// PROCEDURE '%s' status: %s, ", proc,
1665	p_static ? "local" : "global");
1666	printf("starting at line %d,%d: definition end: %d (%d).\n",
1667	yylplineno, current_pos(0), (int)pi->data.s.def_end, brace1);
1668	}
1669	#endif
1670	p_static=FALSE;
1671	#ifndef STANDALONE_PARSER
1672	}
1673	#endif /STANDALONE_PARSER/
1674	}
1675	YY_BREAK
1676	case 9:
1677	YY_RULE_SETUP
1678	#line 364 "libparse.l"
1679	{
1680	BEGIN(pexample);
1681	SET_EXAMPLE_START(mode, pi, yylplineno, current_pos(0));
1682	#if YYLPDEBUG
1683	if(lpverbose)
1684	{
1685	printf("// EXAMPLE at line %d,%d (%d)\n", yylplineno,
1686	current_pos(0), brace1);
1687	}
1688	#endif
1689	}
1690	YY_BREAK
1691	case 10:
1692	YY_RULE_SETUP
1693	#line 376 "libparse.l"
1694	{ quote++;
1695	BEGIN(libcmd);
1696	}
1697	YY_BREAK
1698	case 11:
1699	YY_RULE_SETUP
1700	#line 380 "libparse.l"
1701	{ quote++; brace2++;
1702	BEGIN(libcmd2);
1703	}
1704	YY_BREAK
1705	case 12:
1706	YY_RULE_SETUP
1707	#line 384 "libparse.l"
1708	{
1709	make_version(yytext, 0);
1710	#if YYLPDEBUG > 1
1711	printf("+(id)HEAD:%s\n", yytext);
1712	#endif
1713	}
1714	YY_BREAK
1715	case 13:
1716	YY_RULE_SETUP
1717	#line 390 "libparse.l"
1718	{
1719	#if YYLPDEBUG
1720	printf("+(cmt)HEAD:%s\n", yytext);
1721	#endif
1722	}
1723	YY_BREAK
1724	case 14:
1725	YY_RULE_SETUP
1726	#line 395 "libparse.l"
1727	{
1728	#if YYLPDEBUG > 1
1729	printf("-HEAD:%s\n", yytext);
1730	#endif
1731	}
1732	YY_BREAK
1733	case 15:
1734	YY_RULE_SETUP
1735	#line 400 "libparse.l"
1736	{ yyless(0);
1737	BEGIN(INITIAL);
1738	yymore();
1739	}
1740	YY_BREAK
1741	case 16:
1742	YY_RULE_SETUP
1743	#line 404 "libparse.l"
1744	{
1745	yyless(0);
1746	*lib_style = NEW_LIBSTYLE;
1747	BEGIN(INITIAL);
1748	yymore();
1749	}
1750	YY_BREAK
1751	case 17:
1752	YY_RULE_SETUP
1753	#line 411 "libparse.l"
1754	{ quote++;
1755	BEGIN(libcmd);
1756	}
1757	YY_BREAK
1758	case 18:
1759	YY_RULE_SETUP
1760	#line 414 "libparse.l"
1761	{ quote++; brace2++;
1762	BEGIN(libcmd2);
1763	}
1764	YY_BREAK
1765	case 19:
1766	YY_RULE_SETUP
1767	#line 417 "libparse.l"
1768	{ yylplineno++; }
1769	YY_BREAK
1770	case 20:
1771	YY_RULE_SETUP
1772	#line 418 "libparse.l"
1773	{
1774	#if YYLPDEBUG > 1
1775	printf(" HEAD:%s\n", yytext);
1776	#endif
1777	yyless(0);
1778	BEGIN(help);
1779	}
1780	YY_BREAK
1781	case 21:
1782	YY_RULE_SETUP
1783	#line 425 "libparse.l"
1784	{
1785	#if YYLPDEBUG > 1
1786	printf(" HELP:%s\n", yytext);
1787	#endif
1788	BEGIN(INITIAL); }
1789	YY_BREAK
1790	case 22:
1791	YY_RULE_SETUP
1792	#line 430 "libparse.l"
1793	{
1794	#if YYLPDEBUG > 1
1795	printf(" HELP:%s\n", yytext);
1796	#endif
1797	BEGIN(INITIAL);
1798	}
1799	YY_BREAK
1800	case 23:
1801	YY_RULE_SETUP
1802	#line 436 "libparse.l"
1803	{
1804	yyless(0);
1805	*lib_style = NEW_LIBSTYLE;
1806	BEGIN(INITIAL);
1807	yymore();
1808	}
1809	YY_BREAK
1810	case 24:
1811	YY_RULE_SETUP
1812	#line 442 "libparse.l"
1813	{
1814	yyless(0);
1815	//printf("2) proc found.\n");
1816	BEGIN(INITIAL);
1817	yymore();
1818	}
1819	YY_BREAK
1820	case 25:
1821	YY_RULE_SETUP
1822	#line 448 "libparse.l"
1823	{ quote++;
1824	BEGIN(libcmd);
1825	}
1826	YY_BREAK
1827	case 26:
1828	YY_RULE_SETUP
1829	#line 451 "libparse.l"
1830	{ quote++; brace2++;
1831	BEGIN(libcmd2);
1832	}
1833	YY_BREAK
1834	case 27:
1835	YY_RULE_SETUP
1836	#line 455 "libparse.l"
1837	{ yylplineno++; }
1838	YY_BREAK
1839	case 28:
1840	YY_RULE_SETUP
1841	#line 456 "libparse.l"
1842	{
1843	#if YYLPDEBUG
1844	if(lpverbose>2) printf("--->%s<---\n", yytext);
1845	#endif
1846	}
1847	YY_BREAK
1848	case 29:
1849	YY_RULE_SETUP
1850	#line 461 "libparse.l"
1851	{
1852	found_oldhelp=1;
1853	#if YYLPDEBUG > 1
1854	printf("-HELP:%s\n", yytext);
1855	#endif
1856	}
1857	YY_BREAK
1858	case 30:
1859	YY_RULE_SETUP
1860	#line 469 "libparse.l"
1861	{ quote--;
1862	yytext[yyleng-1] = '\0';
1863	#ifndef STANDALONE_PARSER
1864	if ( mode == LOAD_LIB )
1865	{
1866	library_stack->push(newlib, yytext);
1867	}
1868	#endif /* STANDALONE_PARSER */
1869	#if YYLPDEBUG
1870	if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1871	#endif
1872	BEGIN(INITIAL);
1873	}
1874	YY_BREAK
1875	case 31:
1876	YY_RULE_SETUP
1877	#line 482 "libparse.l"
1878	{ quote--; brace2--;
1879	yytext[yyleng-1] = '\0';
1880	#ifndef STANDALONE_PARSER
1881	if ( mode == LOAD_LIB )
1882	{
1883	library_stack->push(newlib, yytext);
1884	}
1885	#endif /* STANDALONE_PARSER */
1886	#if YYLPDEBUG
1887	if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1888	#endif
1889	BEGIN(INITIAL);
1890	}
1891	YY_BREAK
1892	case 32:
1893	YY_RULE_SETUP
1894	#line 496 "libparse.l"
1895	{ }
1896	YY_BREAK
1897	case 33:
1898	YY_RULE_SETUP
1899	#line 497 "libparse.l"
1900	{
1901	brace2++;
1902	#if YYLPDEBUG > 1
1903	printf("%s", yytext);
1904	#endif
1905	}
1906	YY_BREAK
1907	case 34:
1908	YY_RULE_SETUP
1909	#line 503 "libparse.l"
1910	{
1911	brace2--;
1912	#if YYLPDEBUG > 1
1913	printf(">%s<\n", yytext);
1914	printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1915	#endif
1916	if(brace2<=0)
1917	{
1918	#if YYLPDEBUG > 1
1919	printf("BEGIN(phead){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1920	#endif
1921	SET_DEF_END(mode, pi, current_pos(yyleng));
1922	BEGIN(phead);
1923	}
1924	}
1925	YY_BREAK
1926	case 35:
1927	YY_RULE_SETUP
1928	#line 518 "libparse.l"
1929	{
1930	if(brace2>0)
1931	{
1932	#if YYLPDEBUG > 1
1933	printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1934	#endif
1935	yylp_errno = YYLP_DEF_BR2;
1936	return(1);
1937	}
1938	else
1939	{
1940	brace1++; BEGIN(pbody);
1941	if(lpverbose)
1942	printf("// BODY at line %d,%d (%d)\n", yylplineno,
1943	current_pos(0), brace1);
1944	SET_BODY_START(mode, pi, yylplineno, current_pos(0));
1945	}
1946	}
1947	YY_BREAK
1948	case 36:
1949	YY_RULE_SETUP
1950	#line 536 "libparse.l"
1951	{ yylplineno++;
1952	if(brace2<=0)
1953	{
1954	#if YYLPDEBUG > 1
1955	printf("BEGIN(phead-2){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1956	#endif
1957	BEGIN(phead);
1958	}
1959	}
1960	YY_BREAK
1961	case 37:
1962	YY_RULE_SETUP
1963	#line 545 "libparse.l"
1964	{ }
1965	YY_BREAK
1966	case 38:
1967	YY_RULE_SETUP
1968	#line 546 "libparse.l"
1969	{ old_state = YYSTATE; BEGIN(comment); }
1970	YY_BREAK
1971	case 39:
1972	YY_RULE_SETUP
1973	#line 547 "libparse.l"
1974	{
1975	if(brace2<=0)
1976	{
1977	BEGIN(phead);
1978	yyless(0);
1979	}
1980	}
1981	YY_BREAK
1982	case 40:
1983	YY_RULE_SETUP
1984	#line 555 "libparse.l"
1985	{
1986	#if YYLPDEBUG
1987	if(lpverbose>2)printf("0-Len=%d;\n", yyleng);
1988	#endif
1989	if(check)
1990	{
1991	printf("Procedure %s (line %d) has OLD-STYLE-HELP!\n",
1992	pi->procname, pi->data.s.proc_lineno);
1993	}
1994	SET_HELP_START(mode, pi, current_pos(0));
1995	BEGIN(poldhelp);
1996	yyless(0);
1997	}
1998	YY_BREAK
1999	case 41:
2000	YY_RULE_SETUP
2001	#line 568 "libparse.l"
2002	{
2003	#if YYLPDEBUG
2004	if(lpverbose>2)printf("1-Len=%d;\n", yyleng);
2005	#endif
2006	BEGIN(phelp);
2007	yyless(0);
2008	}
2009	YY_BREAK
2010	case 42:
2011	YY_RULE_SETUP
2012	#line 575 "libparse.l"
2013	{
2014	if(check && yyleng>2)
2015	{
2016	printf("Procedure %s (line %d) has OLD-STYLE-HELP!\n",
2017	pi->procname, pi->data.s.proc_lineno);
2018	}
2019	#if YYLPDEBUG
2020	if(lpverbose>2 && yyleng>2)
2021	printf("2-Len=%d, %s;\n", yyleng, pi->procname);
2022	#endif
2023	SET_HELP_START(mode, pi, current_pos(0));
2024	BEGIN(poldhelp);
2025	yyless(0);
2026	}
2027	YY_BREAK
2028	case 43:
2029	YY_RULE_SETUP
2030	#line 589 "libparse.l"
2031	{ printf("[%s]", yytext); }
2032	YY_BREAK
2033	case 44:
2034	YY_RULE_SETUP
2035	#line 591 "libparse.l"
2036	{ }
2037	YY_BREAK
2038	case 45:
2039	YY_RULE_SETUP
2040	#line 592 "libparse.l"
2041	{
2042	SET_HELP_END(mode, pi, current_pos(0));
2043	brace1++; BEGIN(pbody);
2044	if(lpverbose)
2045	{
2046	printf("// HELP from %d to %d\n",
2047	(int)pi->data.s.help_start, (int)pi->data.s.help_end);
2048	printf("// BODY at line %d,%d (%d)\n", yylplineno,
2049	current_pos(0), brace1);
2050	}
2051	#if YYLPDEBUG > 1
2052	printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2053	#endif
2054	SET_BODY_START(mode, pi, yylplineno, current_pos(0));
2055	#if YYLPDEBUG > 1
2056	printf("BODY at %d/%d", yylplineno, current_pos(0));
2057	#endif
2058	}
2059	YY_BREAK
2060	case 46:
2061	YY_RULE_SETUP
2062	#line 610 "libparse.l"
2063	{ yylplineno++; }
2064	YY_BREAK
2065	case 47:
2066	YY_RULE_SETUP
2067	#line 611 "libparse.l"
2068	{ }
2069	YY_BREAK
2070	case 48:
2071	YY_RULE_SETUP
2072	#line 613 "libparse.l"
2073	{
2074	old_state = YYSTATE;
2075	BEGIN(string);
2076	SET_HELP_START(mode, pi, current_pos(1));
2077	}
2078	YY_BREAK
2079	case 49:
2080	YY_RULE_SETUP
2081	#line 618 "libparse.l"
2082	{}
2083	YY_BREAK
2084	case 50:
2085	YY_RULE_SETUP
2086	#line 619 "libparse.l"
2087	{
2088	brace1++; BEGIN(pbody);
2089	if(lpverbose)
2090	{
2091	printf("// HELP from %d to %d\n",
2092	(int)pi->data.s.help_start, (int)pi->data.s.help_end);
2093	printf("// BODY at line %d,%d (%d)\n", yylplineno,
2094	current_pos(0), brace1);
2095	}
2096	#if YYLPDEBUG > 1
2097	printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2098	#endif
2099	SET_BODY_START(mode, pi, yylplineno, current_pos(0));
2100	#if YYLPDEBUG > 1
2101	printf("BODY at %d/%d", yylplineno, current_pos(0));
2102	#endif
2103	}
2104	YY_BREAK
2105	case 51:
2106	YY_RULE_SETUP
2107	#line 636 "libparse.l"
2108	{ yylplineno++;}
2109	YY_BREAK
2110	case 52:
2111	YY_RULE_SETUP
2112	#line 638 "libparse.l"
2113	{ }
2114	YY_BREAK
2115	case 53:
2116	YY_RULE_SETUP
2117	#line 639 "libparse.l"
2118	{ quote++; old_state = YYSTATE;
2119	BEGIN(string); /* printf("%s", yytext); */
2120	}
2121	YY_BREAK
2122	case 54:
2123	YY_RULE_SETUP
2124	#line 643 "libparse.l"
2125	{
2126	if(check) printf("*** found 2 proc whithin procedure '%s'.\n",
2127	pi->procname);
2128	yyless(yyleng-1);
2129	}
2130	YY_BREAK
2131	case 55:
2132	YY_RULE_SETUP
2133	#line 648 "libparse.l"
2134	{
2135	if(check) printf("*** found 1 proc whithin procedure '%s'.\n",
2136	pi->procname);
2137	yyless(yyleng-1);
2138	}
2139	YY_BREAK
2140	case 56:
2141	YY_RULE_SETUP
2142	#line 653 "libparse.l"
2143	{
2144	brace1++;
2145	#if YYLPDEBUG > 1
2146	printf("line: %d, (%d)%s\n", yylplineno, brace1, yytext);
2147	#endif
2148	}
2149	YY_BREAK
2150	case 57:
2151	YY_RULE_SETUP
2152	#line 659 "libparse.l"
2153	{
2154	#if YYLPDEBUG > 1
2155	printf("line: %d, (%d)%s\n",
2156	yylplineno, brace1, yytext);
2157	#endif
2158	brace1--;
2159	if(brace2>0)
2160	{
2161	yylp_errno = YYLP_BODY_BR2;
2162	return(1);
2163	}
2164	if(brace3>0)
2165	{
2166	yylp_errno = YYLP_BODY_BR3;
2167	return(1);
2168	}
2169	if(brace1<=0)
2170	{
2171	SET_BODY_END(mode, pi, current_pos(yyleng));
2172	SET_PROC_END(mode, pi, current_pos(yyleng));
2173	#if YYLPDEBUG > 1
2174	printf("-%d\n", current_pos(0));
2175	#endif
2176	BEGIN(INITIAL);
2177	}
2178	}
2179	YY_BREAK
2180	case 58:
2181	YY_RULE_SETUP
2182	#line 685 "libparse.l"
2183	{
2184	brace2++; /* printf("%s", yytext); */
2185	}
2186	YY_BREAK
2187	case 59:
2188	YY_RULE_SETUP
2189	#line 688 "libparse.l"
2190	{
2191	brace2--; /* printf("%s", yytext); */
2192	if(brace2<0) {
2193	yylp_errno = YYLP_BODY_TMBR2;
2194	return(1);
2195	}
2196	}
2197	YY_BREAK
2198	case 60:
2199	YY_RULE_SETUP
2200	#line 695 "libparse.l"
2201	{
2202	brace3++; /* printf("%s", yytext); */
2203	}
2204	YY_BREAK
2205	case 61:
2206	YY_RULE_SETUP
2207	#line 698 "libparse.l"
2208	{
2209	brace3--; /* printf("%s", yytext); */
2210	if(brace3<0) {
2211	yylp_errno = YYLP_BODY_TMBR3;
2212	return(1);
2213	}
2214	}
2215	YY_BREAK
2216	case 62:
2217	YY_RULE_SETUP
2218	#line 705 "libparse.l"
2219	{ yylplineno++; }
2220	YY_BREAK
2221	case 63:
2222	YY_RULE_SETUP
2223	#line 706 "libparse.l"
2224	{ }
2225	YY_BREAK
2226	case 64:
2227	YY_RULE_SETUP
2228	#line 708 "libparse.l"
2229	{
2230	quote++; BEGIN(string);
2231	found_info++;
2232	string_start = current_pos(yyleng);
2233	*lib_style = NEW_LIBSTYLE;
2234	last_cmd = LP_INFO;
2235	}
2236	YY_BREAK
2237	case 65:
2238	YY_RULE_SETUP
2239	#line 715 "libparse.l"
2240	{ yylplineno++; }
2241	YY_BREAK
2242	case 66:
2243	YY_RULE_SETUP
2244	#line 716 "libparse.l"
2245	{ }
2246	YY_BREAK
2247	case 67:
2248	YY_RULE_SETUP
2249	#line 718 "libparse.l"
2250	{
2251	quote++; BEGIN(string);
2252	found_cat++;
2253	string_start = current_pos(yyleng);
2254	*lib_style = NEW_LIBSTYLE;
2255	last_cmd = LP_CATEGORY;
2256	}
2257	YY_BREAK
2258	case 68:
2259	YY_RULE_SETUP
2260	#line 725 "libparse.l"
2261	{ yylplineno++; }
2262	YY_BREAK
2263	case 69:
2264	YY_RULE_SETUP
2265	#line 726 "libparse.l"
2266	{ }
2267	YY_BREAK
2268	case 70:
2269	YY_RULE_SETUP
2270	#line 729 "libparse.l"
2271	{ quote--;
2272	copy_string(mode);
2273	last_cmd = LP_NONE;
2274	if(old_state==phelp)
2275	{
2276	SET_HELP_END(mode, pi, current_pos(0));
2277	}
2278	BEGIN(old_state); /* printf("%s", yytext); */
2279	}
2280	YY_BREAK
2281	case 71:
2282	YY_RULE_SETUP
2283	#line 738 "libparse.l"
2284	{ if (old_state == phelp) IncrCheckSum(*yytext);}
2285	YY_BREAK
2286	case 72:
2287	YY_RULE_SETUP
2288	#line 739 "libparse.l"
2289	{ yylplineno++; if (old_state == phelp) IncrCheckSum('\n');}
2290	YY_BREAK
2291	case 73:
2292	YY_RULE_SETUP
2293	#line 740 "libparse.l"
2294	{ if (old_state == phelp) IncrCheckSum(*yytext);}
2295	YY_BREAK
2296	case 74:
2297	YY_RULE_SETUP
2298	#line 742 "libparse.l"
2299	{ }
2300	YY_BREAK
2301	case 75:
2302	YY_RULE_SETUP
2303	#line 743 "libparse.l"
2304	{ quote++; old_state = YYSTATE;
2305	BEGIN(string); /* printf("%s", yytext); */
2306	}
2307	YY_BREAK
2308	case 76:
2309	YY_RULE_SETUP
2310	#line 746 "libparse.l"
2311	{
2312	brace1++; /* printf("(%d)%s", brace1, yytext); */
2313	}
2314	YY_BREAK
2315	case 77:
2316	YY_RULE_SETUP
2317	#line 749 "libparse.l"
2318	{
2319	brace1--; /* printf("(%d)%s", brace1, yytext); */
2320	if(brace1<=0) {
2321	if(brace2>0) { yylp_errno=YYLP_EX_BR2; return(1); }
2322	if(brace3>0) { yylp_errno=YYLP_EX_BR3; return(1); }
2323	BEGIN(INITIAL);
2324	SET_PROC_END(mode, pi, current_pos(yyleng));
2325	}
2326	}
2327	YY_BREAK
2328	case 78:
2329	YY_RULE_SETUP
2330	#line 758 "libparse.l"
2331	{
2332	brace2++; /* printf("%s", yytext); */
2333	}
2334	YY_BREAK
2335	case 79:
2336	YY_RULE_SETUP
2337	#line 761 "libparse.l"
2338	{
2339	brace2--; /* printf("%s", yytext); */
2340	}
2341	YY_BREAK
2342	case 80:
2343	YY_RULE_SETUP
2344	#line 764 "libparse.l"
2345	{
2346	brace3++; /* printf("%s", yytext); */
2347	}
2348	YY_BREAK
2349	case 81:
2350	YY_RULE_SETUP
2351	#line 767 "libparse.l"
2352	{
2353	brace3--; /* printf("%s", yytext); */
2354	}
2355	YY_BREAK
2356	case 82:
2357	YY_RULE_SETUP
2358	#line 770 "libparse.l"
2359	{ yylplineno++; }
2360	YY_BREAK
2361	case 83:
2362	YY_RULE_SETUP
2363	#line 771 "libparse.l"
2364	{ }
2365	YY_BREAK
2366	case 84:
2367	YY_RULE_SETUP
2368	#line 773 "libparse.l"
2369	{ quote--;
2370	BEGIN(pexample); /* printf("%s", yytext); */
2371	}
2372	YY_BREAK
2373	case 85:
2374	YY_RULE_SETUP
2375	#line 776 "libparse.l"
2376	{ }
2377	YY_BREAK
2378	case 86:
2379	YY_RULE_SETUP
2380	#line 777 "libparse.l"
2381	{ }
2382	YY_BREAK
2383	case 87:
2384	YY_RULE_SETUP
2385	#line 778 "libparse.l"
2386	{ yylplineno++; }
2387	YY_BREAK
2388	case 88:
2389	YY_RULE_SETUP
2390	#line 779 "libparse.l"
2391	{ }
2392	YY_BREAK
2393	case 89:
2394	YY_RULE_SETUP
2395	#line 781 "libparse.l"
2396	{ BEGIN(old_state); }
2397	YY_BREAK
2398	case 90:
2399	YY_RULE_SETUP
2400	#line 782 "libparse.l"
2401	{ yylplineno++; }
2402	YY_BREAK
2403	case 91:
2404	YY_RULE_SETUP
2405	#line 783 "libparse.l"
2406	{ }
2407	YY_BREAK
2408	case 92:
2409	YY_RULE_SETUP
2410	#line 785 "libparse.l"
2411	{ yylplineno++; }
2412	YY_BREAK
2413	case 93:
2414	YY_RULE_SETUP
2415	#line 786 "libparse.l"
2416	{ }
2417	YY_BREAK
2418	case 94:
2419	YY_RULE_SETUP
2420	#line 787 "libparse.l"
2421	{ p_static = FALSE;
2422	#if YYLPDEBUG > 1
2423	printf("%s", yytext);
2424	#endif
2425	}
2426	YY_BREAK
2427	case 95:
2428	YY_RULE_SETUP
2429	#line 792 "libparse.l"
2430	{ p_static = FALSE;
2431	yylp_errno = YYLP_BAD_CHAR;
2432	#ifdef STANDALONE_PARSER
2433	printf("[%d]", *yytext);
2434	#else
2435	if (text_buffer!=NULL) omFree((ADDRESS)text_buffer);
2436	text_buffer = omStrDup(yytext);
2437	omMarkAsStaticAddr(text_buffer);
2438	#endif
2439	#if YYLPDEBUG > 1
2440	printf("[%s]", yytext);
2441	#endif
2442	return(1);
2443	}
2444	YY_BREAK
2445	case 96:
2446	YY_RULE_SETUP
2447	#line 807 "libparse.l"
2448	ECHO;
2449	YY_BREAK
2450	case YY_STATE_EOF(INITIAL):
2451	case YY_STATE_EOF(header):
2452	case YY_STATE_EOF(help):
2453	case YY_STATE_EOF(libcmd):
2454	case YY_STATE_EOF(libcmd2):
2455	case YY_STATE_EOF(pdef):
2456	case YY_STATE_EOF(phead):
2457	case YY_STATE_EOF(poldhelp):
2458	case YY_STATE_EOF(phelp):
2459	case YY_STATE_EOF(pbody):
2460	case YY_STATE_EOF(pstr):
2461	case YY_STATE_EOF(pexample):
2462	case YY_STATE_EOF(pestr):
2463	case YY_STATE_EOF(string):
2464	case YY_STATE_EOF(comment):
2465	case YY_STATE_EOF(info):
2466	case YY_STATE_EOF(category):
2467	case YY_STATE_EOF(url):
2468	case YY_STATE_EOF(version):
2469	yyterminate();
2470
2471	case YY_END_OF_BUFFER:
2472	{
2473	/* Amount of text matched not including the EOB char. */
2474	int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2475
2476	/* Undo the effects of YY_DO_BEFORE_ACTION. */
2477	*yy_cp = yy_hold_char;
2478	YY_RESTORE_YY_MORE_OFFSET
2479
2480	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2481	{
2482	/* We're scanning a new file or input source. It's
2483	* possible that this happened because the user
2484	* just pointed yyin at a new source and called
2485	* yylex(). If so, then we have to assure
2486	* consistency between yy_current_buffer and our
2487	* globals. Here is the right place to do so, because
2488	* this is the first action (other than possibly a
2489	* back-up) that will match for the new input source.
2490	*/
2491	yy_n_chars = yy_current_buffer->yy_n_chars;
2492	yy_current_buffer->yy_input_file = yyin;
2493	yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2494	}
2495
2496	/* Note that here we test for yy_c_buf_p "<=" to the position
2497	* of the first EOB in the buffer, since yy_c_buf_p will
2498	* already have been incremented past the NUL character
2499	* (since all states make transitions on EOB to the
2500	* end-of-buffer state). Contrast this with the test
2501	* in input().
2502	*/
2503	if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2504	{ /* This was really a NUL. */
2505	yy_state_type yy_next_state;
2506
2507	yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2508
2509	yy_current_state = yy_get_previous_state();
2510
2511	/* Okay, we're now positioned to make the NUL
2512	* transition. We couldn't have
2513	* yy_get_previous_state() go ahead and do it
2514	* for us because it doesn't know how to deal
2515	* with the possibility of jamming (and we don't
2516	* want to build jamming into it because then it
2517	* will run more slowly).
2518	*/
2519
2520	yy_next_state = yy_try_NUL_trans( yy_current_state );
2521
2522	yy_bp = yytext_ptr + YY_MORE_ADJ;
2523
2524	if ( yy_next_state )
2525	{
2526	/* Consume the NUL. */
2527	yy_cp = ++yy_c_buf_p;
2528	yy_current_state = yy_next_state;
2529	goto yy_match;
2530	}
2531
2532	else
2533	{
2534	yy_cp = yy_c_buf_p;
2535	goto yy_find_action;
2536	}
2537	}
2538
2539	else switch ( yy_get_next_buffer() )
2540	{
2541	case EOB_ACT_END_OF_FILE:
2542	{
2543	yy_did_buffer_switch_on_eof = 0;
2544
2545	if ( yywrap() )
2546	{
2547	/* Note: because we've taken care in
2548	* yy_get_next_buffer() to have set up
2549	* yytext, we can now set up
2550	* yy_c_buf_p so that if some total
2551	* hoser (like flex itself) wants to
2552	* call the scanner after we return the
2553	* YY_NULL, it'll still work - another
2554	* YY_NULL will get returned.
2555	*/
2556	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2557
2558	yy_act = YY_STATE_EOF(YY_START);
2559	goto do_action;
2560	}
2561
2562	else
2563	{
2564	if ( ! yy_did_buffer_switch_on_eof )
2565	YY_NEW_FILE;
2566	}
2567	break;
2568	}
2569
2570	case EOB_ACT_CONTINUE_SCAN:
2571	yy_c_buf_p =
2572	yytext_ptr + yy_amount_of_matched_text;
2573
2574	yy_current_state = yy_get_previous_state();
2575
2576	yy_cp = yy_c_buf_p;
2577	yy_bp = yytext_ptr + YY_MORE_ADJ;
2578	goto yy_match;
2579
2580	case EOB_ACT_LAST_MATCH:
2581	yy_c_buf_p =
2582	&yy_current_buffer->yy_ch_buf[yy_n_chars];
2583
2584	yy_current_state = yy_get_previous_state();
2585
2586	yy_cp = yy_c_buf_p;
2587	yy_bp = yytext_ptr + YY_MORE_ADJ;
2588	goto yy_find_action;
2589	}
2590	break;
2591	}
2592
2593	default:
2594	YY_FATAL_ERROR(
2595	"fatal flex scanner internal error--no action found" );
2596	} /* end of action switch */
2597	} /* end of scanning one token */
2598	} /* end of yylex */
2599
2600
2601	/* yy_get_next_buffer - try to read in a new buffer
2602	*
2603	* Returns a code representing an action:
2604	* EOB_ACT_LAST_MATCH -
2605	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2606	* EOB_ACT_END_OF_FILE - end of file
2607	*/
2608
2609	static int yy_get_next_buffer()
2610	{
2611	register char *dest = yy_current_buffer->yy_ch_buf;
2612	register char *source = yytext_ptr;
2613	register int number_to_move, i;
2614	int ret_val;
2615
2616	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2617	YY_FATAL_ERROR(
2618	"fatal flex scanner internal error--end of buffer missed" );
2619
2620	if ( yy_current_buffer->yy_fill_buffer == 0 )
2621	{ /* Don't try to fill the buffer, so this is an EOF. */
2622	if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2623	{
2624	/* We matched a single character, the EOB, so
2625	* treat this as a final EOF.
2626	*/
2627	return EOB_ACT_END_OF_FILE;
2628	}
2629
2630	else
2631	{
2632	/* We matched some text prior to the EOB, first
2633	* process it.
2634	*/
2635	return EOB_ACT_LAST_MATCH;
2636	}
2637	}
2638
2639	/* Try to read more data. */
2640
2641	/* First move last chars to start of buffer. */
2642	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2643
2644	for ( i = 0; i < number_to_move; ++i )
2645	(dest++) = (source++);
2646
2647	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2648	/* don't do the read, it's not guaranteed to return an EOF,
2649	* just force an EOF
2650	*/
2651	yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2652
2653	else
2654	{
2655	int num_to_read =
2656	yy_current_buffer->yy_buf_size - number_to_move - 1;
2657
2658	while ( num_to_read <= 0 )
2659	{ /* Not enough room in the buffer - grow it. */
2660	#ifdef YY_USES_REJECT
2661	YY_FATAL_ERROR(
2662	"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2663	#else
2664
2665	/* just a shorter name for the current buffer */
2666	YY_BUFFER_STATE b = yy_current_buffer;
2667
2668	int yy_c_buf_p_offset =
2669	(int) (yy_c_buf_p - b->yy_ch_buf);
2670
2671	if ( b->yy_is_our_buffer )
2672	{
2673	int new_size = b->yy_buf_size * 2;
2674
2675	if ( new_size <= 0 )
2676	b->yy_buf_size += b->yy_buf_size / 8;
2677	else
2678	b->yy_buf_size *= 2;
2679
2680	b->yy_ch_buf = (char *)
2681	/* Include room in for 2 EOB chars. */
2682	yy_flex_realloc( (void *) b->yy_ch_buf,
2683	b->yy_buf_size + 2 );
2684	}
2685	else
2686	/* Can't grow it, we don't own it. */
2687	b->yy_ch_buf = 0;
2688
2689	if ( ! b->yy_ch_buf )
2690	YY_FATAL_ERROR(
2691	"fatal error - scanner input buffer overflow" );
2692
2693	yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2694
2695	num_to_read = yy_current_buffer->yy_buf_size -
2696	number_to_move - 1;
2697	#endif
2698	}
2699
2700	if ( num_to_read > YY_READ_BUF_SIZE )
2701	num_to_read = YY_READ_BUF_SIZE;
2702
2703	/* Read in more data. */
2704	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2705	yy_n_chars, num_to_read );
2706
2707	yy_current_buffer->yy_n_chars = yy_n_chars;
2708	}
2709
2710	if ( yy_n_chars == 0 )
2711	{
2712	if ( number_to_move == YY_MORE_ADJ )
2713	{
2714	ret_val = EOB_ACT_END_OF_FILE;
2715	yyrestart( yyin );
2716	}
2717
2718	else
2719	{
2720	ret_val = EOB_ACT_LAST_MATCH;
2721	yy_current_buffer->yy_buffer_status =
2722	YY_BUFFER_EOF_PENDING;
2723	}
2724	}
2725
2726	else
2727	ret_val = EOB_ACT_CONTINUE_SCAN;
2728
2729	yy_n_chars += number_to_move;
2730	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2731	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2732
2733	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2734
2735	return ret_val;
2736	}
2737
2738
2739	/* yy_get_previous_state - get the state just before the EOB char was reached */
2740
2741	static yy_state_type yy_get_previous_state()
2742	{
2743	register yy_state_type yy_current_state;
2744	register char *yy_cp;
2745
2746	yy_current_state = yy_start;
2747	yy_current_state += YY_AT_BOL();
2748
2749	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2750	{
2751	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
2752	if ( yy_accept[yy_current_state] )
2753	{
2754	yy_last_accepting_state = yy_current_state;
2755	yy_last_accepting_cpos = yy_cp;
2756	}
2757	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2758	{
2759	yy_current_state = (int) yy_def[yy_current_state];
2760	if ( yy_current_state >= 485 )
2761	yy_c = yy_meta[(unsigned int) yy_c];
2762	}
2763	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2764	}
2765
2766	return yy_current_state;
2767	}
2768
2769
2770	/* yy_try_NUL_trans - try to make a transition on the NUL character
2771	*
2772	* synopsis
2773	* next_state = yy_try_NUL_trans( current_state );
2774	*/
2775
2776	#ifdef YY_USE_PROTOS
2777	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2778	#else
2779	static yy_state_type yy_try_NUL_trans( yy_current_state )
2780	yy_state_type yy_current_state;
2781	#endif
2782	{
2783	register int yy_is_jam;
2784	register char *yy_cp = yy_c_buf_p;
2785
2786	register YY_CHAR yy_c = 1;
2787	if ( yy_accept[yy_current_state] )
2788	{
2789	yy_last_accepting_state = yy_current_state;
2790	yy_last_accepting_cpos = yy_cp;
2791	}
2792	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2793	{
2794	yy_current_state = (int) yy_def[yy_current_state];
2795	if ( yy_current_state >= 485 )
2796	yy_c = yy_meta[(unsigned int) yy_c];
2797	}
2798	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2799	yy_is_jam = (yy_current_state == 484);
2800
2801	return yy_is_jam ? 0 : yy_current_state;
2802	}
2803
2804
2805	#ifndef YY_NO_UNPUT
2806	#ifdef YY_USE_PROTOS
2807	static void yyunput( int c, register char *yy_bp )
2808	#else
2809	static void yyunput( c, yy_bp )
2810	int c;
2811	register char *yy_bp;
2812	#endif
2813	{
2814	register char *yy_cp = yy_c_buf_p;
2815
2816	/* undo effects of setting up yytext */
2817	*yy_cp = yy_hold_char;
2818
2819	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2820	{ /* need to shift things up to make room */
2821	/* +2 for EOB chars. */
2822	register int number_to_move = yy_n_chars + 2;
2823	register char *dest = &yy_current_buffer->yy_ch_buf[
2824	yy_current_buffer->yy_buf_size + 2];
2825	register char *source =
2826	&yy_current_buffer->yy_ch_buf[number_to_move];
2827
2828	while ( source > yy_current_buffer->yy_ch_buf )
2829	--dest = --source;
2830
2831	yy_cp += (int) (dest - source);
2832	yy_bp += (int) (dest - source);
2833	yy_current_buffer->yy_n_chars =
2834	yy_n_chars = yy_current_buffer->yy_buf_size;
2835
2836	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2837	YY_FATAL_ERROR( "flex scanner push-back overflow" );
2838	}
2839
2840	*--yy_cp = (char) c;
2841
2842
2843	yytext_ptr = yy_bp;
2844	yy_hold_char = *yy_cp;
2845	yy_c_buf_p = yy_cp;
2846	}
2847	#endif /* ifndef YY_NO_UNPUT */
2848
2849
2850	#ifdef __cplusplus
2851	static int yyinput()
2852	#else
2853	static int input()
2854	#endif
2855	{
2856	int c;
2857
2858	*yy_c_buf_p = yy_hold_char;
2859
2860	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2861	{
2862	/* yy_c_buf_p now points to the character we want to return.
2863	* If this occurs before the EOB characters, then it's a
2864	* valid NUL; if not, then we've hit the end of the buffer.
2865	*/
2866	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2867	/* This was really a NUL. */
2868	*yy_c_buf_p = '\0';
2869
2870	else
2871	{ /* need more input */
2872	int offset = yy_c_buf_p - yytext_ptr;
2873	++yy_c_buf_p;
2874
2875	switch ( yy_get_next_buffer() )
2876	{
2877	case EOB_ACT_LAST_MATCH:
2878	/* This happens because yy_g_n_b()
2879	* sees that we've accumulated a
2880	* token and flags that we need to
2881	* try matching the token before
2882	* proceeding. But for input(),
2883	* there's no matching to consider.
2884	* So convert the EOB_ACT_LAST_MATCH
2885	* to EOB_ACT_END_OF_FILE.
2886	*/
2887
2888	/* Reset buffer status. */
2889	yyrestart( yyin );
2890
2891	/* fall through */
2892
2893	case EOB_ACT_END_OF_FILE:
2894	{
2895	if ( yywrap() )
2896	return EOF;
2897
2898	if ( ! yy_did_buffer_switch_on_eof )
2899	YY_NEW_FILE;
2900	#ifdef __cplusplus
2901	return yyinput();
2902	#else
2903	return input();
2904	#endif
2905	}
2906
2907	case EOB_ACT_CONTINUE_SCAN:
2908	yy_c_buf_p = yytext_ptr + offset;
2909	break;
2910	}
2911	}
2912	}
2913
2914	c = (unsigned char ) yy_c_buf_p; /* cast for 8-bit char's */
2915	yy_c_buf_p = '\0'; / preserve yytext */
2916	yy_hold_char = *++yy_c_buf_p;
2917
2918	yy_current_buffer->yy_at_bol = (c == '\n');
2919
2920	return c;
2921	}
2922
2923
2924	#ifdef YY_USE_PROTOS
2925	void yyrestart( FILE *input_file )
2926	#else
2927	void yyrestart( input_file )
2928	FILE *input_file;
2929	#endif
2930	{
2931	if ( ! yy_current_buffer )
2932	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2933
2934	yy_init_buffer( yy_current_buffer, input_file );
2935	yy_load_buffer_state();
2936	}
2937
2938
2939	#ifdef YY_USE_PROTOS
2940	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2941	#else
2942	void yy_switch_to_buffer( new_buffer )
2943	YY_BUFFER_STATE new_buffer;
2944	#endif
2945	{
2946	if ( yy_current_buffer == new_buffer )
2947	return;
2948
2949	if ( yy_current_buffer )
2950	{
2951	/* Flush out information for old buffer. */
2952	*yy_c_buf_p = yy_hold_char;
2953	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2954	yy_current_buffer->yy_n_chars = yy_n_chars;
2955	}
2956
2957	yy_current_buffer = new_buffer;
2958	yy_load_buffer_state();
2959
2960	/* We don't actually know whether we did this switch during
2961	* EOF (yywrap()) processing, but the only time this flag
2962	* is looked at is after yywrap() is called, so it's safe
2963	* to go ahead and always set it.
2964	*/
2965	yy_did_buffer_switch_on_eof = 1;
2966	}
2967
2968
2969	#ifdef YY_USE_PROTOS
2970	void yy_load_buffer_state( void )
2971	#else
2972	void yy_load_buffer_state()
2973	#endif
2974	{
2975	yy_n_chars = yy_current_buffer->yy_n_chars;
2976	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2977	yyin = yy_current_buffer->yy_input_file;
2978	yy_hold_char = *yy_c_buf_p;
2979	}
2980
2981
2982	#ifdef YY_USE_PROTOS
2983	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2984	#else
2985	YY_BUFFER_STATE yy_create_buffer( file, size )
2986	FILE *file;
2987	int size;
2988	#endif
2989	{
2990	YY_BUFFER_STATE b;
2991
2992	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2993	if ( ! b )
2994	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2995
2996	b->yy_buf_size = size;
2997
2998	/* yy_ch_buf has to be 2 characters longer than the size given because
2999	* we need to put in 2 end-of-buffer characters.
3000	*/
3001	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
3002	if ( ! b->yy_ch_buf )
3003	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3004
3005	b->yy_is_our_buffer = 1;
3006
3007	yy_init_buffer( b, file );
3008
3009	return b;
3010	}
3011
3012
3013	#ifdef YY_USE_PROTOS
3014	void yy_delete_buffer( YY_BUFFER_STATE b )
3015	#else
3016	void yy_delete_buffer( b )
3017	YY_BUFFER_STATE b;
3018	#endif
3019	{
3020	if ( ! b )
3021	return;
3022
3023	if ( b == yy_current_buffer )
3024	yy_current_buffer = (YY_BUFFER_STATE) 0;
3025
3026	if ( b->yy_is_our_buffer )
3027	yy_flex_free( (void *) b->yy_ch_buf );
3028
3029	yy_flex_free( (void *) b );
3030	}
3031
3032
3033	#ifndef YY_ALWAYS_INTERACTIVE
3034	#ifndef YY_NEVER_INTERACTIVE
3035	// extern int isatty YY_PROTO(( int ));
3036	#endif
3037	#endif
3038
3039	#ifdef YY_USE_PROTOS
3040	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
3041	#else
3042	void yy_init_buffer( b, file )
3043	YY_BUFFER_STATE b;
3044	FILE *file;
3045	#endif
3046
3047
3048	{
3049	yy_flush_buffer( b );
3050
3051	b->yy_input_file = file;
3052	b->yy_fill_buffer = 1;
3053
3054	#if YY_ALWAYS_INTERACTIVE
3055	b->yy_is_interactive = 1;
3056	#else
3057	#if YY_NEVER_INTERACTIVE
3058	b->yy_is_interactive = 0;
3059	#else
3060	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3061	#endif
3062	#endif
3063	}
3064
3065
3066	#ifdef YY_USE_PROTOS
3067	void yy_flush_buffer( YY_BUFFER_STATE b )
3068	#else
3069	void yy_flush_buffer( b )
3070	YY_BUFFER_STATE b;
3071	#endif
3072
3073	{
3074	if ( ! b )
3075	return;
3076
3077	b->yy_n_chars = 0;
3078
3079	/* We always need two end-of-buffer characters. The first causes
3080	* a transition to the end-of-buffer state. The second causes
3081	* a jam in that state.
3082	*/
3083	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3084	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3085
3086	b->yy_buf_pos = &b->yy_ch_buf[0];
3087
3088	b->yy_at_bol = 1;
3089	b->yy_buffer_status = YY_BUFFER_NEW;
3090
3091	if ( b == yy_current_buffer )
3092	yy_load_buffer_state();
3093	}
3094
3095
3096	#ifndef YY_NO_SCAN_BUFFER
3097	#ifdef YY_USE_PROTOS
3098	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
3099	#else
3100	YY_BUFFER_STATE yy_scan_buffer( base, size )
3101	char *base;
3102	yy_size_t size;
3103	#endif
3104	{
3105	YY_BUFFER_STATE b;
3106
3107	if ( size < 2 \|\|
3108	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
3109	base[size-1] != YY_END_OF_BUFFER_CHAR )
3110	/* They forgot to leave room for the EOB's. */
3111	return 0;
3112
3113	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
3114	if ( ! b )
3115	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3116
3117	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3118	b->yy_buf_pos = b->yy_ch_buf = base;
3119	b->yy_is_our_buffer = 0;
3120	b->yy_input_file = 0;
3121	b->yy_n_chars = b->yy_buf_size;
3122	b->yy_is_interactive = 0;
3123	b->yy_at_bol = 1;
3124	b->yy_fill_buffer = 0;
3125	b->yy_buffer_status = YY_BUFFER_NEW;
3126
3127	yy_switch_to_buffer( b );
3128
3129	return b;
3130	}
3131	#endif
3132
3133
3134	#ifndef YY_NO_SCAN_STRING
3135	#ifdef YY_USE_PROTOS
3136	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
3137	#else
3138	YY_BUFFER_STATE yy_scan_string( yy_str )
3139	yyconst char *yy_str;
3140	#endif
3141	{
3142	int len;
3143	for ( len = 0; yy_str[len]; ++len )
3144	;
3145
3146	return yy_scan_bytes( yy_str, len );
3147	}
3148	#endif
3149
3150
3151	#ifndef YY_NO_SCAN_BYTES
3152	#ifdef YY_USE_PROTOS
3153	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
3154	#else
3155	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
3156	yyconst char *bytes;
3157	int len;
3158	#endif
3159	{
3160	YY_BUFFER_STATE b;
3161	char *buf;
3162	yy_size_t n;
3163	int i;
3164
3165	/* Get memory for full buffer, including space for trailing EOB's. */
3166	n = len + 2;
3167	buf = (char *) yy_flex_alloc( n );
3168	if ( ! buf )
3169	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3170
3171	for ( i = 0; i < len; ++i )
3172	buf[i] = bytes[i];
3173
3174	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
3175
3176	b = yy_scan_buffer( buf, n );
3177	if ( ! b )
3178	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3179
3180	/* It's okay to grow etc. this buffer, and we should throw it
3181	* away when we're done.
3182	*/
3183	b->yy_is_our_buffer = 1;
3184
3185	return b;
3186	}
3187	#endif
3188
3189
3190	#ifndef YY_NO_PUSH_STATE
3191	#ifdef YY_USE_PROTOS
3192	static void yy_push_state( int new_state )
3193	#else
3194	static void yy_push_state( new_state )
3195	int new_state;
3196	#endif
3197	{
3198	if ( yy_start_stack_ptr >= yy_start_stack_depth )
3199	{
3200	yy_size_t new_size;
3201
3202	yy_start_stack_depth += YY_START_STACK_INCR;
3203	new_size = yy_start_stack_depth * sizeof( int );
3204
3205	if ( ! yy_start_stack )
3206	yy_start_stack = (int *) yy_flex_alloc( new_size );
3207
3208	else
3209	yy_start_stack = (int *) yy_flex_realloc(
3210	(void *) yy_start_stack, new_size );
3211
3212	if ( ! yy_start_stack )
3213	YY_FATAL_ERROR(
3214	"out of memory expanding start-condition stack" );
3215	}
3216
3217	yy_start_stack[yy_start_stack_ptr++] = YY_START;
3218
3219	BEGIN(new_state);
3220	}
3221	#endif
3222
3223
3224	#ifndef YY_NO_POP_STATE
3225	static void yy_pop_state()
3226	{
3227	if ( --yy_start_stack_ptr < 0 )
3228	YY_FATAL_ERROR( "start-condition stack underflow" );
3229
3230	BEGIN(yy_start_stack[yy_start_stack_ptr]);
3231	}
3232	#endif
3233
3234
3235	#ifndef YY_NO_TOP_STATE
3236	static int yy_top_state()
3237	{
3238	return yy_start_stack[yy_start_stack_ptr - 1];
3239	}
3240	#endif
3241
3242	#ifndef YY_EXIT_FAILURE
3243	#define YY_EXIT_FAILURE 2
3244	#endif
3245
3246	#ifdef YY_USE_PROTOS
3247	static void yy_fatal_error( yyconst char msg[] )
3248	#else
3249	static void yy_fatal_error( msg )
3250	char msg[];
3251	#endif
3252	{
3253	(void) fprintf( stderr, "%s\n", msg );
3254	exit( YY_EXIT_FAILURE );
3255	}
3256
3257
3258
3259	/* Redefine yyless() so it works in section 3 code. */
3260
3261	#undef yyless
3262	#define yyless(n) \
3263	do \
3264	{ \
3265	/* Undo effects of setting up yytext. */ \
3266	yytext[yyleng] = yy_hold_char; \
3267	yy_c_buf_p = yytext + n; \
3268	yy_hold_char = *yy_c_buf_p; \
3269	*yy_c_buf_p = '\0'; \
3270	yyleng = n; \
3271	} \
3272	while ( 0 )
3273
3274
3275	/* Internal utility routines. */
3276
3277	#ifndef yytext_ptr
3278	#ifdef YY_USE_PROTOS
3279	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
3280	#else
3281	static void yy_flex_strncpy( s1, s2, n )
3282	char *s1;
3283	yyconst char *s2;
3284	int n;
3285	#endif
3286	{
3287	register int i;
3288	for ( i = 0; i < n; ++i )
3289	s1[i] = s2[i];
3290	}
3291	#endif
3292
3293	#ifdef YY_NEED_STRLEN
3294	#ifdef YY_USE_PROTOS
3295	static int yy_flex_strlen( yyconst char *s )
3296	#else
3297	static int yy_flex_strlen( s )
3298	yyconst char *s;
3299	#endif
3300	{
3301	register int n;
3302	for ( n = 0; s[n]; ++n )
3303	;
3304
3305	return n;
3306	}
3307	#endif
3308
3309
3310	#ifdef YY_USE_PROTOS
3311	static void *yy_flex_alloc( yy_size_t size )
3312	#else
3313	static void *yy_flex_alloc( size )
3314	yy_size_t size;
3315	#endif
3316	{
3317	return (void *) malloc( size );
3318	}
3319
3320	#ifdef YY_USE_PROTOS
3321	static void yy_flex_realloc( void ptr, yy_size_t size )
3322	#else
3323	static void *yy_flex_realloc( ptr, size )
3324	void *ptr;
3325	yy_size_t size;
3326	#endif
3327	{
3328	/* The cast to (char *) in the following accommodates both
3329	* implementations that use char* generic pointers, and those
3330	* that use void* generic pointers. It works with the latter
3331	* because both ANSI C and C++ allow castless assignment from
3332	* any pointer type to void*, and deal with argument conversions
3333	* as though doing an assignment.
3334	*/
3335	return (void ) realloc( (char ) ptr, size );
3336	}
3337
3338	#ifdef YY_USE_PROTOS
3339	static void yy_flex_free( void *ptr )
3340	#else
3341	static void yy_flex_free( ptr )
3342	void *ptr;
3343	#endif
3344	{
3345	free( ptr );
3346	}
3347
3348	#if YY_MAIN
3349	int main()
3350	{
3351	yylex();
3352	return 0;
3353	}
3354	#endif
3355	#line 807 "libparse.l"
3356
3357
3358	int current_pos(int i)
3359	{
3360	return(i+offset+(int)(yytext-yylp_buffer_start));
3361	}
3362
3363	int libread(FILE* f, char* buf, int max_size)
3364	{ int rc;
3365
3366	offset = ftell(f);
3367	rc = myfread( buf, 1, max_size, f );
3368	#if YYLPDEBUG >2
3369	printf("fread: %d of %d\n", rc, max_size);
3370	#endif
3371	yylp_buffer_start = buf;
3372	return rc;
3373	}
3374
3375	extern "C" {
3376	int yylpwrap()
3377	{
3378	//printf("======================= YYWRAP ====================\n");
3379	if(brace1>0) { yylp_errno=YYLP_MISS_BR1; }
3380	if(brace2>0) { yylp_errno=YYLP_MISS_BR2; }
3381	if(brace3>0) { yylp_errno=YYLP_MISS_BR3; }
3382	if(quote>0) { yylp_errno=YYLP_MISSQUOT; }
3383	/* printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);/**/
3384	if(feof(yyin)) return 1; else return 0;
3385	}
3386	}
3387
3388	void reinit_yylp()
3389	{
3390	brace1 = 0;
3391	brace2 = 0;
3392	brace3 = 0;
3393	quote = 0;
3394	yy_init=1;
3395	yy_delete_buffer(yy_current_buffer);
3396	}
3397
3398	void make_version(char *p,int what)
3399	{
3400	char ver[10];
3401	char date[16];
3402	ver[0]='?'; ver[1]='.'; ver[2]='?'; ver[3]='\0';
3403	date[0]='?'; date[1]='\0';
3404	if(what) sscanf(p,"%[^=]= %s %*s %10s %16s",ver,date);
3405	else sscanf(p,"// %s %s %10s %16s",ver,date);
3406	strcpy(libnamebuf,"(");
3407	strcat(libnamebuf,ver);
3408	strcat(libnamebuf,",");
3409	strcat(libnamebuf,date);
3410	strcat(libnamebuf,")");
3411	if(what && strcmp(libnamebuf, "(?.?,?)")==0)
3412	{
3413	sscanf(p,"%*[^\"]\"%[^\"]\"",libnamebuf);
3414	}
3415	//printf("ID=(%d)%s; \n", what, p);
3416	}
3417
3418	void copy_string(lp_modes mode)
3419	{
3420	#ifdef STANDALONE_PARSER
3421	if ((texinfo_out
3422	&& (last_cmd == LP_INFO \|\| last_cmd == LP_CATEGORY \|\| last_cmd == LP_URL))
3423	\|\| (category_out && last_cmd == LP_CATEGORY)
3424	)
3425	{
3426	long current_location = ftell(yylpin), i = string_start, quote = 0;
3427	char c;
3428	if (texinfo_out)
3429	{
3430	if (last_cmd == LP_INFO)
3431	{
3432	printf("$info = <<EOT;\n");
3433	}
3434	else if (last_cmd == LP_URL)
3435	{
3436	printf("$url = <<EOT;\n");
3437	}
3438	else
3439	{
3440	printf("$category = <<EOT;\n");
3441	}
3442	}
3443	fseek (yylpin, i, SEEK_SET);
3444	while (i< current_location)
3445	{
3446	c = fgetc(yylpin);
3447	if (c == '\\')
3448	{
3449	quote = (! quote);
3450	}
3451	else if (c == '"')
3452	{
3453	if (! quote) break;
3454	}
3455	else
3456	quote = 0;
3457	if (c == '@' \|\| c == '$') putchar('\\');
3458	if (c != '\r') putchar(c);
3459	i++;
3460	}
3461	if (category_out) exit(0);
3462	fseek (yylpin, current_location, SEEK_SET);
3463	printf("\nEOT\n");
3464	}
3465	#else
3466	if((last_cmd == LP_INFO)&&(mode == GET_INFO))
3467	{
3468	int i, offset=0;
3469	long current_location = ftell(yylpin);
3470	int len = (int)(current_pos(0) - string_start);
3471	fseek(yylpin, string_start, SEEK_SET);
3472	if (text_buffer!=NULL) omFree((ADDRESS)text_buffer);
3473	text_buffer = (char *)omAlloc(len+2);
3474	omMarkAsStaticAddr(text_buffer);
3475	myfread(text_buffer, len, 1, yylpin);
3476	fseek(yylpin, current_location, SEEK_SET);
3477	text_buffer[len]='\0';
3478	offset=0;
3479	for(i=0;i<=len; i++)
3480	{
3481	if(text_buffer[i]=='\\' &&
3482	(text_buffer[i+1]=='\"' \|\| text_buffer[i+1]=='{' \|\|
3483	text_buffer[i+1]=='}' \|\| text_buffer[i+1]=='\\'))
3484	{
3485	i++;
3486	offset++;
3487	}
3488	if(offset>0) text_buffer[i-offset] = text_buffer[i];
3489	}
3490	}
3491	#endif /* STANDALONE_PARSER */
3492	}
3493
3494	void print_init()
3495	{
3496	printf("Init=%d\n", yy_init);
3497	}
3498
3499	void print_version(lp_modes mode, char *p)
3500	{
3501	#ifdef STANDALONE_PARSER
3502	//printf("loading %s%s", p, libnamebuf);
3503	#else
3504	if ( mode == LOAD_LIB )
3505	{
3506	if (BVERBOSE(V_LOAD_LIB) && p!=NULL ) Print(" %s...", p);
3507	//Warn( "loading %s%s", p, libnamebuf);
3508	}
3509	#endif
3510	}
3511
3512	#ifdef STANDALONE_PARSER
3513	main( int argc, char *argv[] )
3514	{
3515	lib_style_types lib_style;
3516	main_init(argc, argv);
3517	if(yyin == NULL)
3518	{
3519	fprintf(stderr, "No library found to parse.\n");
3520	exit(1);
3521	}
3522	if (! (texinfo_out \|\| category_out))
3523	{
3524	if(lpverbose)printf("Verbose level=%d\n", lpverbose);
3525	if(check)printf("Reporting most possible annomalies.\n");
3526	if(lpverbose\|\|check)printf("\n");
3527
3528	printf( " %-15s %20s %s,%s %s,%s %s,%s\n", "Library",
3529	"function", "line", "start-eod", "line", "body-eob",
3530	"line", "example-eoe");
3531	}
3532	yylplex(argv[0], argv[0], &lib_style,NULL);
3533	if(yylp_errno)
3534	{
3535	printf("ERROR occured: [%d] ", yylp_errno);
3536	printf(yylp_errlist[yylp_errno], yylplineno);
3537	printf("\n");
3538	}
3539	else if(pi!=NULL) printpi(pi);
3540	if (texinfo_out)
3541	printf("1;");
3542	exit(0);
3543	}
3544
3545	#endif /* STANDALONE_PARSER */
3546	#endif /* HAVE_LIBPARSE */

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

Download in other formats: