Context Navigation

source: git/Singular/libparse.cc @ 41fbba

spielwiese

Last change on this file since 41fbba was 41fbba, checked in by Hans Schoenemann <hannes@…>, 10 years ago
chg: code cleanup: removed dead code
Property mode set to `100644`
File size: 107.0 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	#include <stdio.h>
1055	#include <string.h>
1056	#include <stdlib.h>
1057	#include <ctype.h>
1058	#ifdef HAVE_CONFIG_H
1059	#include "singularconfig.h"
1060	#endif /* HAVE_CONFIG_H */
1061	#include <kernel/mod2.h>
1062	#ifdef STANDALONE_PARSER
1063	#include <Singular/utils.h>
1064
1065	# ifdef HAVE_FACTORY
1066	int initializeGMP(){ return 1; } // NEEDED FOR MAIN APP. LINKING!!!
1067	int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
1068	# endif
1069
1070	#define HAVE_LIBPARSER
1071	#define YYLPDEBUG 1
1072	#define myfread fread
1073	#else
1074	#include <Singular/subexpr.h>
1075	#include <Singular/grammar.h>
1076	#include <Singular/ipshell.h>
1077	#include <Singular/ipid.h>
1078	#include <Singular/tok.h>
1079	#include <misc/options.h>
1080	#include <kernel/febase.h>
1081	#include <omalloc/omalloc.h>
1082	#endif
1083	#include <Singular/libparse.h>
1084
1085	#ifdef HAVE_LIBPARSER
1086	#define YY_SKIP_YYWRAP
1087
1088	typedef enum { LP_NONE, LP_INFO, LP_CATEGORY, LP_URL, LP_VERSION} lib_cmds;
1089
1090	int libread(FILE* f, char* buf, int max_size);
1091	int current_pos(int i);
1092	void print_version(lp_modes mode, char *p);
1093	void copy_string(lp_modes mode);
1094	extern void piCleanUp(procinfov pi);
1095	void make_version(char *p, int what);
1096
1097	int brace1 = 0; /* { } */
1098	int brace2 = 0; /* ( ) */
1099	int brace3 = 0; /* [ ] */
1100	int quote = 0; /* " */
1101	int offset = 0;
1102	BOOLEAN p_static = FALSE;
1103	int old_state = 0;
1104	lib_cmds last_cmd = LP_NONE;
1105
1106	char libnamebuf[128];
1107	char *text_buffer=NULL;
1108	long string_start;
1109
1110	char *yylp_buffer_start;
1111	int yylplineno = 1;
1112	int lpverbose = 0, check = 0;
1113	int texinfo_out = 0;
1114	int found_info=0,
1115	found_cat=0,
1116	found_version=0,
1117	found_oldhelp = 0,
1118	found_proc_in_proc = 0;
1119
1120	const char *yylp_errlist[]= {
1121	"",
1122	"missing close bracket ')' for proc definition in line %d.", /* 1 */
1123	"missing close bracket ')' for procbody in line %d.", /* 2 */
1124	"missing close bracket ']' for procbody in line %d.", /* 3 */
1125	"too many ')' closed brackets in line %d.", /* 4 */
1126	"too many ']' closed brackets in line %d.", /* 5 */
1127	"missing close bracket ')' for example in line %d.", /* 6 */
1128	"missing close bracket ']' for example in line %d.", /* 7 */
1129	"cannot assign character '%c' in line %d to any group.", /* 8 */
1130	"there must be a quote missing somewhere before line %d.", /* 9 */
1131	"missing close bracket '}' at end of library in line %d.", /* 10 */
1132	"missing close bracket ')' at end of library in line %d.", /* 11 */
1133	"missing close bracket ']' at end of library in line %d.", /* 12 */
1134	NULL
1135	};
1136	int yylp_errno = 0;
1137
1138	#ifdef STANDALONE_PARSER
1139	procinfov pi;
1140	int category_out = 0;
1141	void printpi(procinfov pi);
1142	void pi_clear(procinfov pi);
1143	extern "C" {
1144	int yylpwrap();
1145	}
1146	void main_init(int argc, char *argv[]);
1147	void main_result(char *libname);
1148	#else /* STANDALONE_PARSER */
1149	idhdl h0;
1150	idhdl h_top;
1151	#define pi IDPROC(h0)
1152	extern "C"
1153	{
1154	int yylpwrap();
1155	}
1156	extern libstackv library_stack;
1157	#endif /* STANDALONE_PARSER */
1158
1159	static unsigned long help_chksum;
1160
1161	#define SET_DEF_END(mode, pi, p) \
1162	if ( mode == LOAD_LIB) pi->data.s.def_end = p;
1163	#define SET_HELP_START(mode, pi, p) \
1164	if ( mode == LOAD_LIB) {pi->data.s.help_start = p; help_chksum = 0;}
1165	#define SET_HELP_END(mode, pi, p) \
1166	if ( mode == LOAD_LIB) {pi->data.s.help_end = p; \
1167	pi->data.s.help_chksum = help_chksum;}
1168
1169	#define SET_BODY_START(mode, pi, l, p) \
1170	if ( mode == LOAD_LIB) \
1171	{ \
1172	pi->data.s.body_lineno = l; \
1173	pi->data.s.body_start = p; \
1174	}
1175	#define SET_BODY_END(mode, pi, p) \
1176	if ( mode == LOAD_LIB) \
1177	{ \
1178	pi->data.s.body_end = p-1; \
1179	pi->data.s.proc_end = p-1; \
1180	}
1181
1182	#define SET_EXAMPLE_START(mode, pi, l, p) \
1183	if ( mode == LOAD_LIB) \
1184	{ \
1185	pi->data.s.example_lineno = l; \
1186	pi->data.s.example_start = p; \
1187	}
1188	#define SET_PROC_END(mode, pi, p) \
1189	if ( mode == LOAD_LIB) \
1190	{ \
1191	pi->data.s.proc_end = p-1; \
1192	if(pi->data.s.body_end==0) \
1193	pi->data.s.body_end = p-1; \
1194	}
1195
1196	#define ROTATE_RIGHT(c) if ((c) & 01) (c) = ((c) >>1) + 0x8000; else (c) >>= 1;
1197	#define IncrCheckSum(c) \
1198	do \
1199	{ \
1200	ROTATE_RIGHT(help_chksum); \
1201	help_chksum += c; \
1202	help_chksum &= 0xffff; \
1203	} \
1204	while(0)
1205
1206	#undef YY_DECL
1207	#define YY_DECL int yylex(char newlib, const char libfile, \
1208	lib_style_types *lib_style, \
1209	idhdl pl, BOOLEAN autoexport, lp_modes mode)
1210	#undef YY_INPUT
1211	#define YY_INPUT(buf,result,max_size) \
1212	if ( ((result = libread( (yyin), (char *) buf, max_size )) < 0 ) \
1213	&& ferror( yyin ) ) \
1214	YY_FATAL_ERROR( "read in flex scanner failed" );
1215
1216	#define YY_USER_INIT { \
1217	BEGIN(header); \
1218	yylplineno = 1; \
1219	yylp_errno = 0; \
1220	*lib_style = OLD_LIBSTYLE; \
1221	strcpy(libnamebuf,"(unknown version)"); \
1222	}
1223
1224	#if 0
1225	<pbody>proc[ \t]+{name} {
1226	printf("MISSING: PROC-cmd found. ERROR!\n"); }
1227	<pbody>example[ \t]*\n {
1228	yylplineno++;
1229	printf("MISSING: EXAMPLE-cmd found. ERROR!\n"); }
1230	info=+"\"" {
1231	#endif
1232
1233	/* %start START */
1234	#define header 1
1235
1236	#define help 2
1237
1238	#define libcmd 3
1239
1240	#define libcmd2 4
1241
1242	#define pdef 5
1243
1244	#define phead 6
1245
1246	#define poldhelp 7
1247
1248	#define phelp 8
1249
1250	#define pbody 9
1251
1252	#define pstr 10
1253
1254	#define pexample 11
1255
1256	#define pestr 12
1257
1258	#define string 13
1259
1260	#define comment 14
1261
1262	#define info 15
1263
1264	#define category 16
1265
1266	#define url 17
1267
1268	#define version 18
1269
1270
1271	/* Macros after this point can all be overridden by user definitions in
1272	* section 1.
1273	*/
1274
1275	#ifndef YY_SKIP_YYWRAP
1276	#ifdef __cplusplus
1277	extern "C" int yywrap YY_PROTO(( void ));
1278	#else
1279	extern int yywrap YY_PROTO(( void ));
1280	#endif
1281	#endif
1282
1283	#ifndef YY_NO_UNPUT
1284	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1285	#endif
1286
1287	#ifndef yytext_ptr
1288	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
1289	#endif
1290
1291	#ifdef YY_NEED_STRLEN
1292	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1293	#endif
1294
1295	#ifndef YY_NO_INPUT
1296	#ifdef __cplusplus
1297	static int yyinput YY_PROTO(( void ));
1298	#else
1299	static int input YY_PROTO(( void ));
1300	#endif
1301	#endif
1302
1303	#if YY_STACK_USED
1304	static int yy_start_stack_ptr = 0;
1305	static int yy_start_stack_depth = 0;
1306	static int *yy_start_stack = 0;
1307	#ifndef YY_NO_PUSH_STATE
1308	static void yy_push_state YY_PROTO(( int new_state ));
1309	#endif
1310	#ifndef YY_NO_POP_STATE
1311	static void yy_pop_state YY_PROTO(( void ));
1312	#endif
1313	#ifndef YY_NO_TOP_STATE
1314	static int yy_top_state YY_PROTO(( void ));
1315	#endif
1316
1317	#else
1318	#define YY_NO_PUSH_STATE 1
1319	#define YY_NO_POP_STATE 1
1320	#define YY_NO_TOP_STATE 1
1321	#endif
1322
1323	#ifdef YY_MALLOC_DECL
1324	YY_MALLOC_DECL
1325	#else
1326	#if __STDC__
1327	#ifndef __cplusplus
1328	#include <stdlib.h>
1329	#endif
1330	#else
1331	/* Just try to get by without declaring the routines. This will fail
1332	* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1333	* or sizeof(void*) != sizeof(int).
1334	*/
1335	#endif
1336	#endif
1337
1338	/* Amount of stuff to slurp up with each read. */
1339	#ifndef YY_READ_BUF_SIZE
1340	#define YY_READ_BUF_SIZE 8192
1341	#endif
1342
1343	/* Copy whatever the last rule matched to the standard output. */
1344
1345	#ifndef ECHO
1346	/* This used to be an fputs(), but since the string might contain NUL's,
1347	* we now use fwrite().
1348	*/
1349	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1350	#endif
1351
1352	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1353	* is returned in "result".
1354	*/
1355	#ifndef YY_INPUT
1356	#define YY_INPUT(buf,result,max_size) \
1357	if ( yy_current_buffer->yy_is_interactive ) \
1358	{ \
1359	int c = '*', n; \
1360	for ( n = 0; n < max_size && \
1361	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1362	buf[n] = (char) c; \
1363	if ( c == '\n' ) \
1364	buf[n++] = (char) c; \
1365	if ( c == EOF && ferror( yyin ) ) \
1366	YY_FATAL_ERROR( "input in flex scanner failed" ); \
1367	result = n; \
1368	} \
1369	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1370	&& ferror( yyin ) ) \
1371	YY_FATAL_ERROR( "input in flex scanner failed" );
1372	#endif
1373
1374	/* No semi-colon after return; correct usage is to write "yyterminate();" -
1375	* we don't want an extra ';' after the "return" because that will cause
1376	* some compilers to complain about unreachable statements.
1377	*/
1378	#ifndef yyterminate
1379	#define yyterminate() return YY_NULL
1380	#endif
1381
1382	/* Number of entries by which start-condition stack grows. */
1383	#ifndef YY_START_STACK_INCR
1384	#define YY_START_STACK_INCR 25
1385	#endif
1386
1387	/* Report a fatal error. */
1388	#ifndef YY_FATAL_ERROR
1389	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1390	#endif
1391
1392	/* Default declaration of generated scanner - a define so the user can
1393	* easily add parameters.
1394	*/
1395	#ifndef YY_DECL
1396	#define YY_DECL int yylex YY_PROTO(( void ))
1397	#endif
1398
1399	/* Code executed at the beginning of each rule, after yytext and yyleng
1400	* have been set up.
1401	*/
1402	#ifndef YY_USER_ACTION
1403	#define YY_USER_ACTION
1404	#endif
1405
1406	/* Code executed at the end of each rule. */
1407	#ifndef YY_BREAK
1408	#define YY_BREAK break;
1409	#endif
1410
1411	#define YY_RULE_SETUP \
1412	if ( yyleng > 0 ) \
1413	yy_current_buffer->yy_at_bol = \
1414	(yytext[yyleng - 1] == '\n'); \
1415	YY_USER_ACTION
1416
1417	YY_DECL
1418	{
1419	register yy_state_type yy_current_state;
1420	register char yy_cp = NULL, yy_bp = NULL;
1421	register int yy_act;
1422
1423	#line 228 "libparse.l"
1424
1425
1426	if ( yy_init )
1427	{
1428	yy_init = 0;
1429
1430	#ifdef YY_USER_INIT
1431	YY_USER_INIT;
1432	#endif
1433
1434	if ( ! yy_start )
1435	yy_start = 1; /* first start state */
1436
1437	if ( ! yyin )
1438	yyin = stdin;
1439
1440	if ( ! yyout )
1441	yyout = stdout;
1442
1443	if ( ! yy_current_buffer )
1444	yy_current_buffer =
1445	yy_create_buffer( yyin, YY_BUF_SIZE );
1446
1447	yy_load_buffer_state();
1448	}
1449
1450	while ( 1 ) /* loops until end-of-file is reached */
1451	{
1452	yy_more_len = 0;
1453	if ( yy_more_flag )
1454	{
1455	yy_more_len = yy_c_buf_p - yytext_ptr;
1456	yy_more_flag = 0;
1457	}
1458	yy_cp = yy_c_buf_p;
1459
1460	/* Support of yytext. */
1461	*yy_cp = yy_hold_char;
1462
1463	/* yy_bp points to the position in yy_ch_buf of the start of
1464	* the current run.
1465	*/
1466	yy_bp = yy_cp;
1467
1468	yy_current_state = yy_start;
1469	yy_current_state += YY_AT_BOL();
1470	yy_match:
1471	do
1472	{
1473	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1474	if ( yy_accept[yy_current_state] )
1475	{
1476	yy_last_accepting_state = yy_current_state;
1477	yy_last_accepting_cpos = yy_cp;
1478	}
1479	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1480	{
1481	yy_current_state = (int) yy_def[yy_current_state];
1482	if ( yy_current_state >= 485 )
1483	yy_c = yy_meta[(unsigned int) yy_c];
1484	}
1485	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1486	++yy_cp;
1487	}
1488	while ( yy_base[yy_current_state] != 2200 );
1489
1490	yy_find_action:
1491	yy_act = yy_accept[yy_current_state];
1492	if ( yy_act == 0 )
1493	{ /* have to back up */
1494	yy_cp = yy_last_accepting_cpos;
1495	yy_current_state = yy_last_accepting_state;
1496	yy_act = yy_accept[yy_current_state];
1497	}
1498
1499	YY_DO_BEFORE_ACTION;
1500
1501
1502	do_action: /* This label is used only to access EOF actions. */
1503
1504
1505	switch ( yy_act )
1506	{ /* beginning of action switch */
1507	case 0: /* must back up */
1508	/* undo the effects of YY_DO_BEFORE_ACTION */
1509	*yy_cp = yy_hold_char;
1510	yy_cp = yy_last_accepting_cpos;
1511	yy_current_state = yy_last_accepting_state;
1512	goto yy_find_action;
1513
1514	case 1:
1515	YY_RULE_SETUP
1516	#line 229 "libparse.l"
1517	{ }
1518	YY_BREAK
1519	case 2:
1520	YY_RULE_SETUP
1521	#line 230 "libparse.l"
1522	{ old_state = YYSTATE; BEGIN(comment); }
1523	YY_BREAK
1524	case 3:
1525	YY_RULE_SETUP
1526	#line 232 "libparse.l"
1527	{
1528	yyless(4); old_state = YYSTATE; BEGIN(info);
1529	}
1530	YY_BREAK
1531	case 4:
1532	YY_RULE_SETUP
1533	#line 235 "libparse.l"
1534	{
1535	yyless(8); old_state = YYSTATE; BEGIN(category);
1536	}
1537	YY_BREAK
1538	case 5:
1539	YY_RULE_SETUP
1540	#line 238 "libparse.l"
1541	{
1542	if ( mode != GET_INFO )
1543	{
1544	#ifdef STANDALONE_PARSER
1545	if (texinfo_out)
1546	{
1547	char *c = yytext;
1548	printf("$url = \"");
1549	while ((c != '\0') && (c != '"')) c++;
1550	c++;
1551	while ((c != '\0') && (c != '"'))
1552	{
1553	if (c != '\r') putchar(c);
1554	c++;
1555	}
1556	printf("\";\n");
1557	}
1558	#endif
1559	}
1560	}
1561	YY_BREAK
1562	case 6:
1563	YY_RULE_SETUP
1564	#line 259 "libparse.l"
1565	{
1566	found_version++;
1567	if ( mode != GET_INFO )
1568	{
1569	make_version(yytext,1);
1570	#ifdef STANDALONE_PARSER
1571	if (texinfo_out)
1572	{
1573	char *c = libnamebuf;
1574	printf("$version = \"");
1575	while (*c != '\0')
1576	{
1577	if (c == '$' \|\| c == '@') putchar('\\');
1578	if (c != '\r') putchar(c);
1579	if (*c == '\\')
1580	{
1581	c++;
1582	if (*c != '"') putchar('\\');
1583	}
1584	else
1585	c++;
1586	}
1587	printf("\";\n");
1588	}
1589	else if (!category_out)
1590	printf("Version:%s;\n", libnamebuf);
1591	#else
1592	if (text_buffer!=NULL) omFree((ADDRESS)text_buffer);
1593	text_buffer = omStrDup(libnamebuf);
1594	omMarkAsStaticAddr(text_buffer);
1595	#endif
1596	}
1597	}
1598	YY_BREAK
1599	case 7:
1600	YY_RULE_SETUP
1601	#line 293 "libparse.l"
1602	{ p_static=TRUE; }
1603	YY_BREAK
1604	case 8:
1605	YY_RULE_SETUP
1606	#line 295 "libparse.l"
1607	{
1608	char proc[256];
1609	BEGIN(pdef);
1610	found_proc_in_proc = 0;
1611	proc[0]='\0';
1612	sscanf( yytext, "%*[^p]proc %s", proc);
1613	if(strlen(proc)<1) sscanf( yytext, "proc %s", proc);
1614	#if YYLPDEBUG > 1
1615	printf("Newlib:%s\n", newlib);
1616	#endif
1617	#ifdef STANDALONE_PARSER
1618	if ( pi != NULL )
1619	{
1620	printpi(pi);
1621	pi_clear(pi);
1622	}
1623	pi = (procinfo *)malloc(sizeof(procinfo));
1624	iiInitSingularProcinfo(pi, newlib, proc, yylplineno,
1625	current_pos(0), p_static);
1626	#else /STANDALONE_PARSER/
1627	if( mode == LOAD_LIB)
1628	{
1629	h0 = enterid( proc, 0 /myynest/, PROC_CMD,
1630	&(IDPACKAGE(pl)->idroot), TRUE, !p_static);
1631	if (h0==NULL) return(1);
1632	if((!p_static) && autoexport)
1633	{
1634	package save=currPack;
1635	currPack=basePack;
1636	h_top = enterid( proc, 0 /myynest/, PROC_CMD,
1637	&(basePack->idroot), FALSE );
1638	currPack=save;
1639	if (h_top==NULL) return(1);
1640	}
1641	/* omCheckAddr(IDID(h0)); */
1642	if (h0!=NULL)
1643	{
1644	iiInitSingularProcinfo(IDPROC(h0), newlib, proc,
1645	yylplineno, current_pos(0),p_static);
1646	if ((!p_static) && (h_top != NULL) && autoexport)
1647	{
1648	if(IDPROC(h_top)!=NULL) piCleanUp((procinfo *)IDPROC(h_top));
1649	IDPROC(h_top)=IDPROC(h0);
1650	IDPROC(h_top)->ref++;
1651	}
1652	IDPROC(h0)->pack=IDPACKAGE(pl);
1653	if (BVERBOSE(V_LOAD_PROC))
1654	Warn( " proc '%s' registered", proc );
1655	}
1656	#endif /STANDALONE_PARSER/
1657	SET_DEF_END(mode, pi, current_pos(yyleng+1));
1658	#if YYLPDEBUG
1659	if(lpverbose)
1660	{
1661	printf("// PROCEDURE '%s' status: %s, ", proc,
1662	p_static ? "local" : "global");
1663	printf("starting at line %d,%d: definition end: %d (%d).\n",
1664	yylplineno, current_pos(0), (int)pi->data.s.def_end, brace1);
1665	}
1666	#endif
1667	p_static=FALSE;
1668	#ifndef STANDALONE_PARSER
1669	}
1670	#endif /STANDALONE_PARSER/
1671	}
1672	YY_BREAK
1673	case 9:
1674	YY_RULE_SETUP
1675	#line 364 "libparse.l"
1676	{
1677	BEGIN(pexample);
1678	SET_EXAMPLE_START(mode, pi, yylplineno, current_pos(0));
1679	#if YYLPDEBUG
1680	if(lpverbose)
1681	{
1682	printf("// EXAMPLE at line %d,%d (%d)\n", yylplineno,
1683	current_pos(0), brace1);
1684	}
1685	#endif
1686	}
1687	YY_BREAK
1688	case 10:
1689	YY_RULE_SETUP
1690	#line 376 "libparse.l"
1691	{ quote++;
1692	BEGIN(libcmd);
1693	}
1694	YY_BREAK
1695	case 11:
1696	YY_RULE_SETUP
1697	#line 380 "libparse.l"
1698	{ quote++; brace2++;
1699	BEGIN(libcmd2);
1700	}
1701	YY_BREAK
1702	case 12:
1703	YY_RULE_SETUP
1704	#line 384 "libparse.l"
1705	{
1706	make_version(yytext, 0);
1707	#if YYLPDEBUG > 1
1708	printf("+(id)HEAD:%s\n", yytext);
1709	#endif
1710	}
1711	YY_BREAK
1712	case 13:
1713	YY_RULE_SETUP
1714	#line 390 "libparse.l"
1715	{
1716	#if YYLPDEBUG
1717	printf("+(cmt)HEAD:%s\n", yytext);
1718	#endif
1719	}
1720	YY_BREAK
1721	case 14:
1722	YY_RULE_SETUP
1723	#line 395 "libparse.l"
1724	{
1725	#if YYLPDEBUG > 1
1726	printf("-HEAD:%s\n", yytext);
1727	#endif
1728	}
1729	YY_BREAK
1730	case 15:
1731	YY_RULE_SETUP
1732	#line 400 "libparse.l"
1733	{ yyless(0);
1734	BEGIN(INITIAL);
1735	yymore();
1736	}
1737	YY_BREAK
1738	case 16:
1739	YY_RULE_SETUP
1740	#line 404 "libparse.l"
1741	{
1742	yyless(0);
1743	*lib_style = NEW_LIBSTYLE;
1744	BEGIN(INITIAL);
1745	yymore();
1746	}
1747	YY_BREAK
1748	case 17:
1749	YY_RULE_SETUP
1750	#line 411 "libparse.l"
1751	{ quote++;
1752	BEGIN(libcmd);
1753	}
1754	YY_BREAK
1755	case 18:
1756	YY_RULE_SETUP
1757	#line 414 "libparse.l"
1758	{ quote++; brace2++;
1759	BEGIN(libcmd2);
1760	}
1761	YY_BREAK
1762	case 19:
1763	YY_RULE_SETUP
1764	#line 417 "libparse.l"
1765	{ yylplineno++; }
1766	YY_BREAK
1767	case 20:
1768	YY_RULE_SETUP
1769	#line 418 "libparse.l"
1770	{
1771	#if YYLPDEBUG > 1
1772	printf(" HEAD:%s\n", yytext);
1773	#endif
1774	yyless(0);
1775	BEGIN(help);
1776	}
1777	YY_BREAK
1778	case 21:
1779	YY_RULE_SETUP
1780	#line 425 "libparse.l"
1781	{
1782	#if YYLPDEBUG > 1
1783	printf(" HELP:%s\n", yytext);
1784	#endif
1785	BEGIN(INITIAL); }
1786	YY_BREAK
1787	case 22:
1788	YY_RULE_SETUP
1789	#line 430 "libparse.l"
1790	{
1791	#if YYLPDEBUG > 1
1792	printf(" HELP:%s\n", yytext);
1793	#endif
1794	BEGIN(INITIAL);
1795	}
1796	YY_BREAK
1797	case 23:
1798	YY_RULE_SETUP
1799	#line 436 "libparse.l"
1800	{
1801	yyless(0);
1802	*lib_style = NEW_LIBSTYLE;
1803	BEGIN(INITIAL);
1804	yymore();
1805	}
1806	YY_BREAK
1807	case 24:
1808	YY_RULE_SETUP
1809	#line 442 "libparse.l"
1810	{
1811	yyless(0);
1812	//printf("2) proc found.\n");
1813	BEGIN(INITIAL);
1814	yymore();
1815	}
1816	YY_BREAK
1817	case 25:
1818	YY_RULE_SETUP
1819	#line 448 "libparse.l"
1820	{ quote++;
1821	BEGIN(libcmd);
1822	}
1823	YY_BREAK
1824	case 26:
1825	YY_RULE_SETUP
1826	#line 451 "libparse.l"
1827	{ quote++; brace2++;
1828	BEGIN(libcmd2);
1829	}
1830	YY_BREAK
1831	case 27:
1832	YY_RULE_SETUP
1833	#line 455 "libparse.l"
1834	{ yylplineno++; }
1835	YY_BREAK
1836	case 28:
1837	YY_RULE_SETUP
1838	#line 456 "libparse.l"
1839	{
1840	#if YYLPDEBUG
1841	if(lpverbose>2) printf("--->%s<---\n", yytext);
1842	#endif
1843	}
1844	YY_BREAK
1845	case 29:
1846	YY_RULE_SETUP
1847	#line 461 "libparse.l"
1848	{
1849	found_oldhelp=1;
1850	#if YYLPDEBUG > 1
1851	printf("-HELP:%s\n", yytext);
1852	#endif
1853	}
1854	YY_BREAK
1855	case 30:
1856	YY_RULE_SETUP
1857	#line 469 "libparse.l"
1858	{ quote--;
1859	yytext[yyleng-1] = '\0';
1860	#ifndef STANDALONE_PARSER
1861	if ( mode == LOAD_LIB )
1862	{
1863	library_stack->push(newlib, yytext);
1864	}
1865	#endif /* STANDALONE_PARSER */
1866	#if YYLPDEBUG
1867	if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1868	#endif
1869	BEGIN(INITIAL);
1870	}
1871	YY_BREAK
1872	case 31:
1873	YY_RULE_SETUP
1874	#line 482 "libparse.l"
1875	{ quote--; brace2--;
1876	yytext[yyleng-1] = '\0';
1877	#ifndef STANDALONE_PARSER
1878	if ( mode == LOAD_LIB )
1879	{
1880	library_stack->push(newlib, yytext);
1881	}
1882	#endif /* STANDALONE_PARSER */
1883	#if YYLPDEBUG
1884	if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1885	#endif
1886	BEGIN(INITIAL);
1887	}
1888	YY_BREAK
1889	case 32:
1890	YY_RULE_SETUP
1891	#line 496 "libparse.l"
1892	{ }
1893	YY_BREAK
1894	case 33:
1895	YY_RULE_SETUP
1896	#line 497 "libparse.l"
1897	{
1898	brace2++;
1899	#if YYLPDEBUG > 1
1900	printf("%s", yytext);
1901	#endif
1902	}
1903	YY_BREAK
1904	case 34:
1905	YY_RULE_SETUP
1906	#line 503 "libparse.l"
1907	{
1908	brace2--;
1909	#if YYLPDEBUG > 1
1910	printf(">%s<\n", yytext);
1911	printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1912	#endif
1913	if(brace2<=0)
1914	{
1915	#if YYLPDEBUG > 1
1916	printf("BEGIN(phead){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1917	#endif
1918	SET_DEF_END(mode, pi, current_pos(yyleng));
1919	BEGIN(phead);
1920	}
1921	}
1922	YY_BREAK
1923	case 35:
1924	YY_RULE_SETUP
1925	#line 518 "libparse.l"
1926	{
1927	if(brace2>0)
1928	{
1929	#if YYLPDEBUG > 1
1930	printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1931	#endif
1932	yylp_errno = YYLP_DEF_BR2;
1933	return(1);
1934	}
1935	else
1936	{
1937	brace1++; BEGIN(pbody);
1938	if(lpverbose)
1939	printf("// BODY at line %d,%d (%d)\n", yylplineno,
1940	current_pos(0), brace1);
1941	SET_BODY_START(mode, pi, yylplineno, current_pos(0));
1942	}
1943	}
1944	YY_BREAK
1945	case 36:
1946	YY_RULE_SETUP
1947	#line 536 "libparse.l"
1948	{ yylplineno++;
1949	if(brace2<=0)
1950	{
1951	#if YYLPDEBUG > 1
1952	printf("BEGIN(phead-2){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1953	#endif
1954	BEGIN(phead);
1955	}
1956	}
1957	YY_BREAK
1958	case 37:
1959	YY_RULE_SETUP
1960	#line 545 "libparse.l"
1961	{ }
1962	YY_BREAK
1963	case 38:
1964	YY_RULE_SETUP
1965	#line 546 "libparse.l"
1966	{ old_state = YYSTATE; BEGIN(comment); }
1967	YY_BREAK
1968	case 39:
1969	YY_RULE_SETUP
1970	#line 547 "libparse.l"
1971	{
1972	if(brace2<=0)
1973	{
1974	BEGIN(phead);
1975	yyless(0);
1976	}
1977	}
1978	YY_BREAK
1979	case 40:
1980	YY_RULE_SETUP
1981	#line 555 "libparse.l"
1982	{
1983	#if YYLPDEBUG
1984	if(lpverbose>2)printf("0-Len=%d;\n", yyleng);
1985	#endif
1986	if(check)
1987	{
1988	printf("Procedure %s (line %d) has OLD-STYLE-HELP!\n",
1989	pi->procname, pi->data.s.proc_lineno);
1990	}
1991	SET_HELP_START(mode, pi, current_pos(0));
1992	BEGIN(poldhelp);
1993	yyless(0);
1994	}
1995	YY_BREAK
1996	case 41:
1997	YY_RULE_SETUP
1998	#line 568 "libparse.l"
1999	{
2000	#if YYLPDEBUG
2001	if(lpverbose>2)printf("1-Len=%d;\n", yyleng);
2002	#endif
2003	BEGIN(phelp);
2004	yyless(0);
2005	}
2006	YY_BREAK
2007	case 42:
2008	YY_RULE_SETUP
2009	#line 575 "libparse.l"
2010	{
2011	if(check && yyleng>2)
2012	{
2013	printf("Procedure %s (line %d) has OLD-STYLE-HELP!\n",
2014	pi->procname, pi->data.s.proc_lineno);
2015	}
2016	#if YYLPDEBUG
2017	if(lpverbose>2 && yyleng>2)
2018	printf("2-Len=%d, %s;\n", yyleng, pi->procname);
2019	#endif
2020	SET_HELP_START(mode, pi, current_pos(0));
2021	BEGIN(poldhelp);
2022	yyless(0);
2023	}
2024	YY_BREAK
2025	case 43:
2026	YY_RULE_SETUP
2027	#line 589 "libparse.l"
2028	{ printf("[%s]", yytext); }
2029	YY_BREAK
2030	case 44:
2031	YY_RULE_SETUP
2032	#line 591 "libparse.l"
2033	{ }
2034	YY_BREAK
2035	case 45:
2036	YY_RULE_SETUP
2037	#line 592 "libparse.l"
2038	{
2039	SET_HELP_END(mode, pi, current_pos(0));
2040	brace1++; BEGIN(pbody);
2041	if(lpverbose)
2042	{
2043	printf("// HELP from %d to %d\n",
2044	(int)pi->data.s.help_start, (int)pi->data.s.help_end);
2045	printf("// BODY at line %d,%d (%d)\n", yylplineno,
2046	current_pos(0), brace1);
2047	}
2048	#if YYLPDEBUG > 1
2049	printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2050	#endif
2051	SET_BODY_START(mode, pi, yylplineno, current_pos(0));
2052	#if YYLPDEBUG > 1
2053	printf("BODY at %d/%d", yylplineno, current_pos(0));
2054	#endif
2055	}
2056	YY_BREAK
2057	case 46:
2058	YY_RULE_SETUP
2059	#line 610 "libparse.l"
2060	{ yylplineno++; }
2061	YY_BREAK
2062	case 47:
2063	YY_RULE_SETUP
2064	#line 611 "libparse.l"
2065	{ }
2066	YY_BREAK
2067	case 48:
2068	YY_RULE_SETUP
2069	#line 613 "libparse.l"
2070	{
2071	old_state = YYSTATE;
2072	BEGIN(string);
2073	SET_HELP_START(mode, pi, current_pos(1));
2074	}
2075	YY_BREAK
2076	case 49:
2077	YY_RULE_SETUP
2078	#line 618 "libparse.l"
2079	{}
2080	YY_BREAK
2081	case 50:
2082	YY_RULE_SETUP
2083	#line 619 "libparse.l"
2084	{
2085	brace1++; BEGIN(pbody);
2086	if(lpverbose)
2087	{
2088	printf("// HELP from %d to %d\n",
2089	(int)pi->data.s.help_start, (int)pi->data.s.help_end);
2090	printf("// BODY at line %d,%d (%d)\n", yylplineno,
2091	current_pos(0), brace1);
2092	}
2093	#if YYLPDEBUG > 1
2094	printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2095	#endif
2096	SET_BODY_START(mode, pi, yylplineno, current_pos(0));
2097	#if YYLPDEBUG > 1
2098	printf("BODY at %d/%d", yylplineno, current_pos(0));
2099	#endif
2100	}
2101	YY_BREAK
2102	case 51:
2103	YY_RULE_SETUP
2104	#line 636 "libparse.l"
2105	{ yylplineno++;}
2106	YY_BREAK
2107	case 52:
2108	YY_RULE_SETUP
2109	#line 638 "libparse.l"
2110	{ }
2111	YY_BREAK
2112	case 53:
2113	YY_RULE_SETUP
2114	#line 639 "libparse.l"
2115	{ quote++; old_state = YYSTATE;
2116	BEGIN(string); /* printf("%s", yytext); */
2117	}
2118	YY_BREAK
2119	case 54:
2120	YY_RULE_SETUP
2121	#line 643 "libparse.l"
2122	{
2123	if(check) printf("*** found 2 proc whithin procedure '%s'.\n",
2124	pi->procname);
2125	yyless(yyleng-1);
2126	}
2127	YY_BREAK
2128	case 55:
2129	YY_RULE_SETUP
2130	#line 648 "libparse.l"
2131	{
2132	if(check) printf("*** found 1 proc whithin procedure '%s'.\n",
2133	pi->procname);
2134	yyless(yyleng-1);
2135	}
2136	YY_BREAK
2137	case 56:
2138	YY_RULE_SETUP
2139	#line 653 "libparse.l"
2140	{
2141	brace1++;
2142	#if YYLPDEBUG > 1
2143	printf("line: %d, (%d)%s\n", yylplineno, brace1, yytext);
2144	#endif
2145	}
2146	YY_BREAK
2147	case 57:
2148	YY_RULE_SETUP
2149	#line 659 "libparse.l"
2150	{
2151	#if YYLPDEBUG > 1
2152	printf("line: %d, (%d)%s\n",
2153	yylplineno, brace1, yytext);
2154	#endif
2155	brace1--;
2156	if(brace2>0)
2157	{
2158	yylp_errno = YYLP_BODY_BR2;
2159	return(1);
2160	}
2161	if(brace3>0)
2162	{
2163	yylp_errno = YYLP_BODY_BR3;
2164	return(1);
2165	}
2166	if(brace1<=0)
2167	{
2168	SET_BODY_END(mode, pi, current_pos(yyleng));
2169	SET_PROC_END(mode, pi, current_pos(yyleng));
2170	#if YYLPDEBUG > 1
2171	printf("-%d\n", current_pos(0));
2172	#endif
2173	BEGIN(INITIAL);
2174	}
2175	}
2176	YY_BREAK
2177	case 58:
2178	YY_RULE_SETUP
2179	#line 685 "libparse.l"
2180	{
2181	brace2++; /* printf("%s", yytext); */
2182	}
2183	YY_BREAK
2184	case 59:
2185	YY_RULE_SETUP
2186	#line 688 "libparse.l"
2187	{
2188	brace2--; /* printf("%s", yytext); */
2189	if(brace2<0) {
2190	yylp_errno = YYLP_BODY_TMBR2;
2191	return(1);
2192	}
2193	}
2194	YY_BREAK
2195	case 60:
2196	YY_RULE_SETUP
2197	#line 695 "libparse.l"
2198	{
2199	brace3++; /* printf("%s", yytext); */
2200	}
2201	YY_BREAK
2202	case 61:
2203	YY_RULE_SETUP
2204	#line 698 "libparse.l"
2205	{
2206	brace3--; /* printf("%s", yytext); */
2207	if(brace3<0) {
2208	yylp_errno = YYLP_BODY_TMBR3;
2209	return(1);
2210	}
2211	}
2212	YY_BREAK
2213	case 62:
2214	YY_RULE_SETUP
2215	#line 705 "libparse.l"
2216	{ yylplineno++; }
2217	YY_BREAK
2218	case 63:
2219	YY_RULE_SETUP
2220	#line 706 "libparse.l"
2221	{ }
2222	YY_BREAK
2223	case 64:
2224	YY_RULE_SETUP
2225	#line 708 "libparse.l"
2226	{
2227	quote++; BEGIN(string);
2228	found_info++;
2229	string_start = current_pos(yyleng);
2230	*lib_style = NEW_LIBSTYLE;
2231	last_cmd = LP_INFO;
2232	}
2233	YY_BREAK
2234	case 65:
2235	YY_RULE_SETUP
2236	#line 715 "libparse.l"
2237	{ yylplineno++; }
2238	YY_BREAK
2239	case 66:
2240	YY_RULE_SETUP
2241	#line 716 "libparse.l"
2242	{ }
2243	YY_BREAK
2244	case 67:
2245	YY_RULE_SETUP
2246	#line 718 "libparse.l"
2247	{
2248	quote++; BEGIN(string);
2249	found_cat++;
2250	string_start = current_pos(yyleng);
2251	*lib_style = NEW_LIBSTYLE;
2252	last_cmd = LP_CATEGORY;
2253	}
2254	YY_BREAK
2255	case 68:
2256	YY_RULE_SETUP
2257	#line 725 "libparse.l"
2258	{ yylplineno++; }
2259	YY_BREAK
2260	case 69:
2261	YY_RULE_SETUP
2262	#line 726 "libparse.l"
2263	{ }
2264	YY_BREAK
2265	case 70:
2266	YY_RULE_SETUP
2267	#line 729 "libparse.l"
2268	{ quote--;
2269	copy_string(mode);
2270	last_cmd = LP_NONE;
2271	if(old_state==phelp)
2272	{
2273	SET_HELP_END(mode, pi, current_pos(0));
2274	}
2275	BEGIN(old_state); /* printf("%s", yytext); */
2276	}
2277	YY_BREAK
2278	case 71:
2279	YY_RULE_SETUP
2280	#line 738 "libparse.l"
2281	{ if (old_state == phelp) IncrCheckSum(*yytext);}
2282	YY_BREAK
2283	case 72:
2284	YY_RULE_SETUP
2285	#line 739 "libparse.l"
2286	{ yylplineno++; if (old_state == phelp) IncrCheckSum('\n');}
2287	YY_BREAK
2288	case 73:
2289	YY_RULE_SETUP
2290	#line 740 "libparse.l"
2291	{ if (old_state == phelp) IncrCheckSum(*yytext);}
2292	YY_BREAK
2293	case 74:
2294	YY_RULE_SETUP
2295	#line 742 "libparse.l"
2296	{ }
2297	YY_BREAK
2298	case 75:
2299	YY_RULE_SETUP
2300	#line 743 "libparse.l"
2301	{ quote++; old_state = YYSTATE;
2302	BEGIN(string); /* printf("%s", yytext); */
2303	}
2304	YY_BREAK
2305	case 76:
2306	YY_RULE_SETUP
2307	#line 746 "libparse.l"
2308	{
2309	brace1++; /* printf("(%d)%s", brace1, yytext); */
2310	}
2311	YY_BREAK
2312	case 77:
2313	YY_RULE_SETUP
2314	#line 749 "libparse.l"
2315	{
2316	brace1--; /* printf("(%d)%s", brace1, yytext); */
2317	if(brace1<=0) {
2318	if(brace2>0) { yylp_errno=YYLP_EX_BR2; return(1); }
2319	if(brace3>0) { yylp_errno=YYLP_EX_BR3; return(1); }
2320	BEGIN(INITIAL);
2321	SET_PROC_END(mode, pi, current_pos(yyleng));
2322	}
2323	}
2324	YY_BREAK
2325	case 78:
2326	YY_RULE_SETUP
2327	#line 758 "libparse.l"
2328	{
2329	brace2++; /* printf("%s", yytext); */
2330	}
2331	YY_BREAK
2332	case 79:
2333	YY_RULE_SETUP
2334	#line 761 "libparse.l"
2335	{
2336	brace2--; /* printf("%s", yytext); */
2337	}
2338	YY_BREAK
2339	case 80:
2340	YY_RULE_SETUP
2341	#line 764 "libparse.l"
2342	{
2343	brace3++; /* printf("%s", yytext); */
2344	}
2345	YY_BREAK
2346	case 81:
2347	YY_RULE_SETUP
2348	#line 767 "libparse.l"
2349	{
2350	brace3--; /* printf("%s", yytext); */
2351	}
2352	YY_BREAK
2353	case 82:
2354	YY_RULE_SETUP
2355	#line 770 "libparse.l"
2356	{ yylplineno++; }
2357	YY_BREAK
2358	case 83:
2359	YY_RULE_SETUP
2360	#line 771 "libparse.l"
2361	{ }
2362	YY_BREAK
2363	case 84:
2364	YY_RULE_SETUP
2365	#line 773 "libparse.l"
2366	{ quote--;
2367	BEGIN(pexample); /* printf("%s", yytext); */
2368	}
2369	YY_BREAK
2370	case 85:
2371	YY_RULE_SETUP
2372	#line 776 "libparse.l"
2373	{ }
2374	YY_BREAK
2375	case 86:
2376	YY_RULE_SETUP
2377	#line 777 "libparse.l"
2378	{ }
2379	YY_BREAK
2380	case 87:
2381	YY_RULE_SETUP
2382	#line 778 "libparse.l"
2383	{ yylplineno++; }
2384	YY_BREAK
2385	case 88:
2386	YY_RULE_SETUP
2387	#line 779 "libparse.l"
2388	{ }
2389	YY_BREAK
2390	case 89:
2391	YY_RULE_SETUP
2392	#line 781 "libparse.l"
2393	{ BEGIN(old_state); }
2394	YY_BREAK
2395	case 90:
2396	YY_RULE_SETUP
2397	#line 782 "libparse.l"
2398	{ yylplineno++; }
2399	YY_BREAK
2400	case 91:
2401	YY_RULE_SETUP
2402	#line 783 "libparse.l"
2403	{ }
2404	YY_BREAK
2405	case 92:
2406	YY_RULE_SETUP
2407	#line 785 "libparse.l"
2408	{ yylplineno++; }
2409	YY_BREAK
2410	case 93:
2411	YY_RULE_SETUP
2412	#line 786 "libparse.l"
2413	{ }
2414	YY_BREAK
2415	case 94:
2416	YY_RULE_SETUP
2417	#line 787 "libparse.l"
2418	{ p_static = FALSE;
2419	#if YYLPDEBUG > 1
2420	printf("%s", yytext);
2421	#endif
2422	}
2423	YY_BREAK
2424	case 95:
2425	YY_RULE_SETUP
2426	#line 792 "libparse.l"
2427	{ p_static = FALSE;
2428	yylp_errno = YYLP_BAD_CHAR;
2429	#ifdef STANDALONE_PARSER
2430	printf("[%d]", *yytext);
2431	#else
2432	if (text_buffer!=NULL) omFree((ADDRESS)text_buffer);
2433	text_buffer = omStrDup(yytext);
2434	omMarkAsStaticAddr(text_buffer);
2435	#endif
2436	#if YYLPDEBUG > 1
2437	printf("[%s]", yytext);
2438	#endif
2439	return(1);
2440	}
2441	YY_BREAK
2442	case 96:
2443	YY_RULE_SETUP
2444	#line 807 "libparse.l"
2445	ECHO;
2446	YY_BREAK
2447	case YY_STATE_EOF(INITIAL):
2448	case YY_STATE_EOF(header):
2449	case YY_STATE_EOF(help):
2450	case YY_STATE_EOF(libcmd):
2451	case YY_STATE_EOF(libcmd2):
2452	case YY_STATE_EOF(pdef):
2453	case YY_STATE_EOF(phead):
2454	case YY_STATE_EOF(poldhelp):
2455	case YY_STATE_EOF(phelp):
2456	case YY_STATE_EOF(pbody):
2457	case YY_STATE_EOF(pstr):
2458	case YY_STATE_EOF(pexample):
2459	case YY_STATE_EOF(pestr):
2460	case YY_STATE_EOF(string):
2461	case YY_STATE_EOF(comment):
2462	case YY_STATE_EOF(info):
2463	case YY_STATE_EOF(category):
2464	case YY_STATE_EOF(url):
2465	case YY_STATE_EOF(version):
2466	yyterminate();
2467
2468	case YY_END_OF_BUFFER:
2469	{
2470	/* Amount of text matched not including the EOB char. */
2471	int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2472
2473	/* Undo the effects of YY_DO_BEFORE_ACTION. */
2474	*yy_cp = yy_hold_char;
2475	YY_RESTORE_YY_MORE_OFFSET
2476
2477	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2478	{
2479	/* We're scanning a new file or input source. It's
2480	* possible that this happened because the user
2481	* just pointed yyin at a new source and called
2482	* yylex(). If so, then we have to assure
2483	* consistency between yy_current_buffer and our
2484	* globals. Here is the right place to do so, because
2485	* this is the first action (other than possibly a
2486	* back-up) that will match for the new input source.
2487	*/
2488	yy_n_chars = yy_current_buffer->yy_n_chars;
2489	yy_current_buffer->yy_input_file = yyin;
2490	yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2491	}
2492
2493	/* Note that here we test for yy_c_buf_p "<=" to the position
2494	* of the first EOB in the buffer, since yy_c_buf_p will
2495	* already have been incremented past the NUL character
2496	* (since all states make transitions on EOB to the
2497	* end-of-buffer state). Contrast this with the test
2498	* in input().
2499	*/
2500	if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2501	{ /* This was really a NUL. */
2502	yy_state_type yy_next_state;
2503
2504	yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2505
2506	yy_current_state = yy_get_previous_state();
2507
2508	/* Okay, we're now positioned to make the NUL
2509	* transition. We couldn't have
2510	* yy_get_previous_state() go ahead and do it
2511	* for us because it doesn't know how to deal
2512	* with the possibility of jamming (and we don't
2513	* want to build jamming into it because then it
2514	* will run more slowly).
2515	*/
2516
2517	yy_next_state = yy_try_NUL_trans( yy_current_state );
2518
2519	yy_bp = yytext_ptr + YY_MORE_ADJ;
2520
2521	if ( yy_next_state )
2522	{
2523	/* Consume the NUL. */
2524	yy_cp = ++yy_c_buf_p;
2525	yy_current_state = yy_next_state;
2526	goto yy_match;
2527	}
2528
2529	else
2530	{
2531	yy_cp = yy_c_buf_p;
2532	goto yy_find_action;
2533	}
2534	}
2535
2536	else switch ( yy_get_next_buffer() )
2537	{
2538	case EOB_ACT_END_OF_FILE:
2539	{
2540	yy_did_buffer_switch_on_eof = 0;
2541
2542	if ( yywrap() )
2543	{
2544	/* Note: because we've taken care in
2545	* yy_get_next_buffer() to have set up
2546	* yytext, we can now set up
2547	* yy_c_buf_p so that if some total
2548	* hoser (like flex itself) wants to
2549	* call the scanner after we return the
2550	* YY_NULL, it'll still work - another
2551	* YY_NULL will get returned.
2552	*/
2553	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2554
2555	yy_act = YY_STATE_EOF(YY_START);
2556	goto do_action;
2557	}
2558
2559	else
2560	{
2561	if ( ! yy_did_buffer_switch_on_eof )
2562	YY_NEW_FILE;
2563	}
2564	break;
2565	}
2566
2567	case EOB_ACT_CONTINUE_SCAN:
2568	yy_c_buf_p =
2569	yytext_ptr + yy_amount_of_matched_text;
2570
2571	yy_current_state = yy_get_previous_state();
2572
2573	yy_cp = yy_c_buf_p;
2574	yy_bp = yytext_ptr + YY_MORE_ADJ;
2575	goto yy_match;
2576
2577	case EOB_ACT_LAST_MATCH:
2578	yy_c_buf_p =
2579	&yy_current_buffer->yy_ch_buf[yy_n_chars];
2580
2581	yy_current_state = yy_get_previous_state();
2582
2583	yy_cp = yy_c_buf_p;
2584	yy_bp = yytext_ptr + YY_MORE_ADJ;
2585	goto yy_find_action;
2586	}
2587	break;
2588	}
2589
2590	default:
2591	YY_FATAL_ERROR(
2592	"fatal flex scanner internal error--no action found" );
2593	} /* end of action switch */
2594	} /* end of scanning one token */
2595	} /* end of yylex */
2596
2597
2598	/* yy_get_next_buffer - try to read in a new buffer
2599	*
2600	* Returns a code representing an action:
2601	* EOB_ACT_LAST_MATCH -
2602	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2603	* EOB_ACT_END_OF_FILE - end of file
2604	*/
2605
2606	static int yy_get_next_buffer()
2607	{
2608	register char *dest = yy_current_buffer->yy_ch_buf;
2609	register char *source = yytext_ptr;
2610	register int number_to_move, i;
2611	int ret_val;
2612
2613	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2614	YY_FATAL_ERROR(
2615	"fatal flex scanner internal error--end of buffer missed" );
2616
2617	if ( yy_current_buffer->yy_fill_buffer == 0 )
2618	{ /* Don't try to fill the buffer, so this is an EOF. */
2619	if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2620	{
2621	/* We matched a single character, the EOB, so
2622	* treat this as a final EOF.
2623	*/
2624	return EOB_ACT_END_OF_FILE;
2625	}
2626
2627	else
2628	{
2629	/* We matched some text prior to the EOB, first
2630	* process it.
2631	*/
2632	return EOB_ACT_LAST_MATCH;
2633	}
2634	}
2635
2636	/* Try to read more data. */
2637
2638	/* First move last chars to start of buffer. */
2639	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2640
2641	for ( i = 0; i < number_to_move; ++i )
2642	(dest++) = (source++);
2643
2644	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2645	/* don't do the read, it's not guaranteed to return an EOF,
2646	* just force an EOF
2647	*/
2648	yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2649
2650	else
2651	{
2652	int num_to_read =
2653	yy_current_buffer->yy_buf_size - number_to_move - 1;
2654
2655	while ( num_to_read <= 0 )
2656	{ /* Not enough room in the buffer - grow it. */
2657	#ifdef YY_USES_REJECT
2658	YY_FATAL_ERROR(
2659	"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2660	#else
2661
2662	/* just a shorter name for the current buffer */
2663	YY_BUFFER_STATE b = yy_current_buffer;
2664
2665	int yy_c_buf_p_offset =
2666	(int) (yy_c_buf_p - b->yy_ch_buf);
2667
2668	if ( b->yy_is_our_buffer )
2669	{
2670	int new_size = b->yy_buf_size * 2;
2671
2672	if ( new_size <= 0 )
2673	b->yy_buf_size += b->yy_buf_size / 8;
2674	else
2675	b->yy_buf_size *= 2;
2676
2677	b->yy_ch_buf = (char *)
2678	/* Include room in for 2 EOB chars. */
2679	yy_flex_realloc( (void *) b->yy_ch_buf,
2680	b->yy_buf_size + 2 );
2681	}
2682	else
2683	/* Can't grow it, we don't own it. */
2684	b->yy_ch_buf = 0;
2685
2686	if ( ! b->yy_ch_buf )
2687	YY_FATAL_ERROR(
2688	"fatal error - scanner input buffer overflow" );
2689
2690	yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2691
2692	num_to_read = yy_current_buffer->yy_buf_size -
2693	number_to_move - 1;
2694	#endif
2695	}
2696
2697	if ( num_to_read > YY_READ_BUF_SIZE )
2698	num_to_read = YY_READ_BUF_SIZE;
2699
2700	/* Read in more data. */
2701	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2702	yy_n_chars, num_to_read );
2703
2704	yy_current_buffer->yy_n_chars = yy_n_chars;
2705	}
2706
2707	if ( yy_n_chars == 0 )
2708	{
2709	if ( number_to_move == YY_MORE_ADJ )
2710	{
2711	ret_val = EOB_ACT_END_OF_FILE;
2712	yyrestart( yyin );
2713	}
2714
2715	else
2716	{
2717	ret_val = EOB_ACT_LAST_MATCH;
2718	yy_current_buffer->yy_buffer_status =
2719	YY_BUFFER_EOF_PENDING;
2720	}
2721	}
2722
2723	else
2724	ret_val = EOB_ACT_CONTINUE_SCAN;
2725
2726	yy_n_chars += number_to_move;
2727	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2728	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2729
2730	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2731
2732	return ret_val;
2733	}
2734
2735
2736	/* yy_get_previous_state - get the state just before the EOB char was reached */
2737
2738	static yy_state_type yy_get_previous_state()
2739	{
2740	register yy_state_type yy_current_state;
2741	register char *yy_cp;
2742
2743	yy_current_state = yy_start;
2744	yy_current_state += YY_AT_BOL();
2745
2746	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2747	{
2748	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
2749	if ( yy_accept[yy_current_state] )
2750	{
2751	yy_last_accepting_state = yy_current_state;
2752	yy_last_accepting_cpos = yy_cp;
2753	}
2754	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2755	{
2756	yy_current_state = (int) yy_def[yy_current_state];
2757	if ( yy_current_state >= 485 )
2758	yy_c = yy_meta[(unsigned int) yy_c];
2759	}
2760	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2761	}
2762
2763	return yy_current_state;
2764	}
2765
2766
2767	/* yy_try_NUL_trans - try to make a transition on the NUL character
2768	*
2769	* synopsis
2770	* next_state = yy_try_NUL_trans( current_state );
2771	*/
2772
2773	#ifdef YY_USE_PROTOS
2774	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2775	#else
2776	static yy_state_type yy_try_NUL_trans( yy_current_state )
2777	yy_state_type yy_current_state;
2778	#endif
2779	{
2780	register int yy_is_jam;
2781	register char *yy_cp = yy_c_buf_p;
2782
2783	register YY_CHAR yy_c = 1;
2784	if ( yy_accept[yy_current_state] )
2785	{
2786	yy_last_accepting_state = yy_current_state;
2787	yy_last_accepting_cpos = yy_cp;
2788	}
2789	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2790	{
2791	yy_current_state = (int) yy_def[yy_current_state];
2792	if ( yy_current_state >= 485 )
2793	yy_c = yy_meta[(unsigned int) yy_c];
2794	}
2795	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2796	yy_is_jam = (yy_current_state == 484);
2797
2798	return yy_is_jam ? 0 : yy_current_state;
2799	}
2800
2801
2802	#ifndef YY_NO_UNPUT
2803	#ifdef YY_USE_PROTOS
2804	static void yyunput( int c, register char *yy_bp )
2805	#else
2806	static void yyunput( c, yy_bp )
2807	int c;
2808	register char *yy_bp;
2809	#endif
2810	{
2811	register char *yy_cp = yy_c_buf_p;
2812
2813	/* undo effects of setting up yytext */
2814	*yy_cp = yy_hold_char;
2815
2816	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2817	{ /* need to shift things up to make room */
2818	/* +2 for EOB chars. */
2819	register int number_to_move = yy_n_chars + 2;
2820	register char *dest = &yy_current_buffer->yy_ch_buf[
2821	yy_current_buffer->yy_buf_size + 2];
2822	register char *source =
2823	&yy_current_buffer->yy_ch_buf[number_to_move];
2824
2825	while ( source > yy_current_buffer->yy_ch_buf )
2826	--dest = --source;
2827
2828	yy_cp += (int) (dest - source);
2829	yy_bp += (int) (dest - source);
2830	yy_current_buffer->yy_n_chars =
2831	yy_n_chars = yy_current_buffer->yy_buf_size;
2832
2833	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2834	YY_FATAL_ERROR( "flex scanner push-back overflow" );
2835	}
2836
2837	*--yy_cp = (char) c;
2838
2839
2840	yytext_ptr = yy_bp;
2841	yy_hold_char = *yy_cp;
2842	yy_c_buf_p = yy_cp;
2843	}
2844	#endif /* ifndef YY_NO_UNPUT */
2845
2846
2847	#ifdef __cplusplus
2848	static int yyinput()
2849	#else
2850	static int input()
2851	#endif
2852	{
2853	int c;
2854
2855	*yy_c_buf_p = yy_hold_char;
2856
2857	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2858	{
2859	/* yy_c_buf_p now points to the character we want to return.
2860	* If this occurs before the EOB characters, then it's a
2861	* valid NUL; if not, then we've hit the end of the buffer.
2862	*/
2863	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2864	/* This was really a NUL. */
2865	*yy_c_buf_p = '\0';
2866
2867	else
2868	{ /* need more input */
2869	int offset = yy_c_buf_p - yytext_ptr;
2870	++yy_c_buf_p;
2871
2872	switch ( yy_get_next_buffer() )
2873	{
2874	case EOB_ACT_LAST_MATCH:
2875	/* This happens because yy_g_n_b()
2876	* sees that we've accumulated a
2877	* token and flags that we need to
2878	* try matching the token before
2879	* proceeding. But for input(),
2880	* there's no matching to consider.
2881	* So convert the EOB_ACT_LAST_MATCH
2882	* to EOB_ACT_END_OF_FILE.
2883	*/
2884
2885	/* Reset buffer status. */
2886	yyrestart( yyin );
2887
2888	/* fall through */
2889
2890	case EOB_ACT_END_OF_FILE:
2891	{
2892	if ( yywrap() )
2893	return EOF;
2894
2895	if ( ! yy_did_buffer_switch_on_eof )
2896	YY_NEW_FILE;
2897	#ifdef __cplusplus
2898	return yyinput();
2899	#else
2900	return input();
2901	#endif
2902	}
2903
2904	case EOB_ACT_CONTINUE_SCAN:
2905	yy_c_buf_p = yytext_ptr + offset;
2906	break;
2907	}
2908	}
2909	}
2910
2911	c = (unsigned char ) yy_c_buf_p; /* cast for 8-bit char's */
2912	yy_c_buf_p = '\0'; / preserve yytext */
2913	yy_hold_char = *++yy_c_buf_p;
2914
2915	yy_current_buffer->yy_at_bol = (c == '\n');
2916
2917	return c;
2918	}
2919
2920
2921	#ifdef YY_USE_PROTOS
2922	void yyrestart( FILE *input_file )
2923	#else
2924	void yyrestart( input_file )
2925	FILE *input_file;
2926	#endif
2927	{
2928	if ( ! yy_current_buffer )
2929	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2930
2931	yy_init_buffer( yy_current_buffer, input_file );
2932	yy_load_buffer_state();
2933	}
2934
2935
2936	#ifdef YY_USE_PROTOS
2937	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2938	#else
2939	void yy_switch_to_buffer( new_buffer )
2940	YY_BUFFER_STATE new_buffer;
2941	#endif
2942	{
2943	if ( yy_current_buffer == new_buffer )
2944	return;
2945
2946	if ( yy_current_buffer )
2947	{
2948	/* Flush out information for old buffer. */
2949	*yy_c_buf_p = yy_hold_char;
2950	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2951	yy_current_buffer->yy_n_chars = yy_n_chars;
2952	}
2953
2954	yy_current_buffer = new_buffer;
2955	yy_load_buffer_state();
2956
2957	/* We don't actually know whether we did this switch during
2958	* EOF (yywrap()) processing, but the only time this flag
2959	* is looked at is after yywrap() is called, so it's safe
2960	* to go ahead and always set it.
2961	*/
2962	yy_did_buffer_switch_on_eof = 1;
2963	}
2964
2965
2966	#ifdef YY_USE_PROTOS
2967	void yy_load_buffer_state( void )
2968	#else
2969	void yy_load_buffer_state()
2970	#endif
2971	{
2972	yy_n_chars = yy_current_buffer->yy_n_chars;
2973	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2974	yyin = yy_current_buffer->yy_input_file;
2975	yy_hold_char = *yy_c_buf_p;
2976	}
2977
2978
2979	#ifdef YY_USE_PROTOS
2980	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2981	#else
2982	YY_BUFFER_STATE yy_create_buffer( file, size )
2983	FILE *file;
2984	int size;
2985	#endif
2986	{
2987	YY_BUFFER_STATE b;
2988
2989	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2990	if ( ! b )
2991	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2992
2993	b->yy_buf_size = size;
2994
2995	/* yy_ch_buf has to be 2 characters longer than the size given because
2996	* we need to put in 2 end-of-buffer characters.
2997	*/
2998	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2999	if ( ! b->yy_ch_buf )
3000	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3001
3002	b->yy_is_our_buffer = 1;
3003
3004	yy_init_buffer( b, file );
3005
3006	return b;
3007	}
3008
3009
3010	#ifdef YY_USE_PROTOS
3011	void yy_delete_buffer( YY_BUFFER_STATE b )
3012	#else
3013	void yy_delete_buffer( b )
3014	YY_BUFFER_STATE b;
3015	#endif
3016	{
3017	if ( ! b )
3018	return;
3019
3020	if ( b == yy_current_buffer )
3021	yy_current_buffer = (YY_BUFFER_STATE) 0;
3022
3023	if ( b->yy_is_our_buffer )
3024	yy_flex_free( (void *) b->yy_ch_buf );
3025
3026	yy_flex_free( (void *) b );
3027	}
3028
3029
3030	#ifndef YY_ALWAYS_INTERACTIVE
3031	#ifndef YY_NEVER_INTERACTIVE
3032	// extern int isatty YY_PROTO(( int ));
3033	#endif
3034	#endif
3035
3036	#ifdef YY_USE_PROTOS
3037	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
3038	#else
3039	void yy_init_buffer( b, file )
3040	YY_BUFFER_STATE b;
3041	FILE *file;
3042	#endif
3043
3044
3045	{
3046	yy_flush_buffer( b );
3047
3048	b->yy_input_file = file;
3049	b->yy_fill_buffer = 1;
3050
3051	#if YY_ALWAYS_INTERACTIVE
3052	b->yy_is_interactive = 1;
3053	#else
3054	#if YY_NEVER_INTERACTIVE
3055	b->yy_is_interactive = 0;
3056	#else
3057	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3058	#endif
3059	#endif
3060	}
3061
3062
3063	#ifdef YY_USE_PROTOS
3064	void yy_flush_buffer( YY_BUFFER_STATE b )
3065	#else
3066	void yy_flush_buffer( b )
3067	YY_BUFFER_STATE b;
3068	#endif
3069
3070	{
3071	if ( ! b )
3072	return;
3073
3074	b->yy_n_chars = 0;
3075
3076	/* We always need two end-of-buffer characters. The first causes
3077	* a transition to the end-of-buffer state. The second causes
3078	* a jam in that state.
3079	*/
3080	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3081	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3082
3083	b->yy_buf_pos = &b->yy_ch_buf[0];
3084
3085	b->yy_at_bol = 1;
3086	b->yy_buffer_status = YY_BUFFER_NEW;
3087
3088	if ( b == yy_current_buffer )
3089	yy_load_buffer_state();
3090	}
3091
3092
3093	#ifndef YY_NO_SCAN_BUFFER
3094	#ifdef YY_USE_PROTOS
3095	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
3096	#else
3097	YY_BUFFER_STATE yy_scan_buffer( base, size )
3098	char *base;
3099	yy_size_t size;
3100	#endif
3101	{
3102	YY_BUFFER_STATE b;
3103
3104	if ( size < 2 \|\|
3105	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
3106	base[size-1] != YY_END_OF_BUFFER_CHAR )
3107	/* They forgot to leave room for the EOB's. */
3108	return 0;
3109
3110	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
3111	if ( ! b )
3112	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3113
3114	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3115	b->yy_buf_pos = b->yy_ch_buf = base;
3116	b->yy_is_our_buffer = 0;
3117	b->yy_input_file = 0;
3118	b->yy_n_chars = b->yy_buf_size;
3119	b->yy_is_interactive = 0;
3120	b->yy_at_bol = 1;
3121	b->yy_fill_buffer = 0;
3122	b->yy_buffer_status = YY_BUFFER_NEW;
3123
3124	yy_switch_to_buffer( b );
3125
3126	return b;
3127	}
3128	#endif
3129
3130
3131	#ifndef YY_NO_SCAN_STRING
3132	#ifdef YY_USE_PROTOS
3133	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
3134	#else
3135	YY_BUFFER_STATE yy_scan_string( yy_str )
3136	yyconst char *yy_str;
3137	#endif
3138	{
3139	int len;
3140	for ( len = 0; yy_str[len]; ++len )
3141	;
3142
3143	return yy_scan_bytes( yy_str, len );
3144	}
3145	#endif
3146
3147
3148	#ifndef YY_NO_SCAN_BYTES
3149	#ifdef YY_USE_PROTOS
3150	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
3151	#else
3152	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
3153	yyconst char *bytes;
3154	int len;
3155	#endif
3156	{
3157	YY_BUFFER_STATE b;
3158	char *buf;
3159	yy_size_t n;
3160	int i;
3161
3162	/* Get memory for full buffer, including space for trailing EOB's. */
3163	n = len + 2;
3164	buf = (char *) yy_flex_alloc( n );
3165	if ( ! buf )
3166	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3167
3168	for ( i = 0; i < len; ++i )
3169	buf[i] = bytes[i];
3170
3171	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
3172
3173	b = yy_scan_buffer( buf, n );
3174	if ( ! b )
3175	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3176
3177	/* It's okay to grow etc. this buffer, and we should throw it
3178	* away when we're done.
3179	*/
3180	b->yy_is_our_buffer = 1;
3181
3182	return b;
3183	}
3184	#endif
3185
3186
3187	#ifndef YY_NO_PUSH_STATE
3188	#ifdef YY_USE_PROTOS
3189	static void yy_push_state( int new_state )
3190	#else
3191	static void yy_push_state( new_state )
3192	int new_state;
3193	#endif
3194	{
3195	if ( yy_start_stack_ptr >= yy_start_stack_depth )
3196	{
3197	yy_size_t new_size;
3198
3199	yy_start_stack_depth += YY_START_STACK_INCR;
3200	new_size = yy_start_stack_depth * sizeof( int );
3201
3202	if ( ! yy_start_stack )
3203	yy_start_stack = (int *) yy_flex_alloc( new_size );
3204
3205	else
3206	yy_start_stack = (int *) yy_flex_realloc(
3207	(void *) yy_start_stack, new_size );
3208
3209	if ( ! yy_start_stack )
3210	YY_FATAL_ERROR(
3211	"out of memory expanding start-condition stack" );
3212	}
3213
3214	yy_start_stack[yy_start_stack_ptr++] = YY_START;
3215
3216	BEGIN(new_state);
3217	}
3218	#endif
3219
3220
3221	#ifndef YY_NO_POP_STATE
3222	static void yy_pop_state()
3223	{
3224	if ( --yy_start_stack_ptr < 0 )
3225	YY_FATAL_ERROR( "start-condition stack underflow" );
3226
3227	BEGIN(yy_start_stack[yy_start_stack_ptr]);
3228	}
3229	#endif
3230
3231
3232	#ifndef YY_NO_TOP_STATE
3233	static int yy_top_state()
3234	{
3235	return yy_start_stack[yy_start_stack_ptr - 1];
3236	}
3237	#endif
3238
3239	#ifndef YY_EXIT_FAILURE
3240	#define YY_EXIT_FAILURE 2
3241	#endif
3242
3243	#ifdef YY_USE_PROTOS
3244	static void yy_fatal_error( yyconst char msg[] )
3245	#else
3246	static void yy_fatal_error( msg )
3247	char msg[];
3248	#endif
3249	{
3250	(void) fprintf( stderr, "%s\n", msg );
3251	exit( YY_EXIT_FAILURE );
3252	}
3253
3254
3255
3256	/* Redefine yyless() so it works in section 3 code. */
3257
3258	#undef yyless
3259	#define yyless(n) \
3260	do \
3261	{ \
3262	/* Undo effects of setting up yytext. */ \
3263	yytext[yyleng] = yy_hold_char; \
3264	yy_c_buf_p = yytext + n; \
3265	yy_hold_char = *yy_c_buf_p; \
3266	*yy_c_buf_p = '\0'; \
3267	yyleng = n; \
3268	} \
3269	while ( 0 )
3270
3271
3272	/* Internal utility routines. */
3273
3274	#ifndef yytext_ptr
3275	#ifdef YY_USE_PROTOS
3276	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
3277	#else
3278	static void yy_flex_strncpy( s1, s2, n )
3279	char *s1;
3280	yyconst char *s2;
3281	int n;
3282	#endif
3283	{
3284	register int i;
3285	for ( i = 0; i < n; ++i )
3286	s1[i] = s2[i];
3287	}
3288	#endif
3289
3290	#ifdef YY_NEED_STRLEN
3291	#ifdef YY_USE_PROTOS
3292	static int yy_flex_strlen( yyconst char *s )
3293	#else
3294	static int yy_flex_strlen( s )
3295	yyconst char *s;
3296	#endif
3297	{
3298	register int n;
3299	for ( n = 0; s[n]; ++n )
3300	;
3301
3302	return n;
3303	}
3304	#endif
3305
3306
3307	#ifdef YY_USE_PROTOS
3308	static void *yy_flex_alloc( yy_size_t size )
3309	#else
3310	static void *yy_flex_alloc( size )
3311	yy_size_t size;
3312	#endif
3313	{
3314	return (void *) malloc( size );
3315	}
3316
3317	#ifdef YY_USE_PROTOS
3318	static void yy_flex_realloc( void ptr, yy_size_t size )
3319	#else
3320	static void *yy_flex_realloc( ptr, size )
3321	void *ptr;
3322	yy_size_t size;
3323	#endif
3324	{
3325	/* The cast to (char *) in the following accommodates both
3326	* implementations that use char* generic pointers, and those
3327	* that use void* generic pointers. It works with the latter
3328	* because both ANSI C and C++ allow castless assignment from
3329	* any pointer type to void*, and deal with argument conversions
3330	* as though doing an assignment.
3331	*/
3332	return (void ) realloc( (char ) ptr, size );
3333	}
3334
3335	#ifdef YY_USE_PROTOS
3336	static void yy_flex_free( void *ptr )
3337	#else
3338	static void yy_flex_free( ptr )
3339	void *ptr;
3340	#endif
3341	{
3342	free( ptr );
3343	}
3344
3345	#if YY_MAIN
3346	int main()
3347	{
3348	yylex();
3349	return 0;
3350	}
3351	#endif
3352	#line 807 "libparse.l"
3353
3354
3355	int current_pos(int i)
3356	{
3357	return(i+offset+(int)(yytext-yylp_buffer_start));
3358	}
3359
3360	int libread(FILE* f, char* buf, int max_size)
3361	{ int rc;
3362
3363	offset = ftell(f);
3364	rc = myfread( buf, 1, max_size, f );
3365	#if YYLPDEBUG >2
3366	printf("fread: %d of %d\n", rc, max_size);
3367	#endif
3368	yylp_buffer_start = buf;
3369	return rc;
3370	}
3371
3372	extern "C" {
3373	int yylpwrap()
3374	{
3375	//printf("======================= YYWRAP ====================\n");
3376	if(brace1>0) { yylp_errno=YYLP_MISS_BR1; }
3377	if(brace2>0) { yylp_errno=YYLP_MISS_BR2; }
3378	if(brace3>0) { yylp_errno=YYLP_MISS_BR3; }
3379	if(quote>0) { yylp_errno=YYLP_MISSQUOT; }
3380	/* printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);/**/
3381	if(feof(yyin)) return 1; else return 0;
3382	}
3383	}
3384
3385	void reinit_yylp()
3386	{
3387	brace1 = 0;
3388	brace2 = 0;
3389	brace3 = 0;
3390	quote = 0;
3391	yy_init=1;
3392	yy_delete_buffer(yy_current_buffer);
3393	}
3394
3395	void make_version(char *p,int what)
3396	{
3397	char ver[10];
3398	char date[16];
3399	ver[0]='?'; ver[1]='.'; ver[2]='?'; ver[3]='\0';
3400	date[0]='?'; date[1]='\0';
3401	if(what) sscanf(p,"%[^=]= %s %*s %10s %16s",ver,date);
3402	else sscanf(p,"// %s %s %10s %16s",ver,date);
3403	strcpy(libnamebuf,"(");
3404	strcat(libnamebuf,ver);
3405	strcat(libnamebuf,",");
3406	strcat(libnamebuf,date);
3407	strcat(libnamebuf,")");
3408	if(what && strcmp(libnamebuf, "(?.?,?)")==0)
3409	{
3410	sscanf(p,"%*[^\"]\"%[^\"]\"",libnamebuf);
3411	}
3412	//printf("ID=(%d)%s; \n", what, p);
3413	}
3414
3415	void copy_string(lp_modes mode)
3416	{
3417	#ifdef STANDALONE_PARSER
3418	if ((texinfo_out
3419	&& (last_cmd == LP_INFO \|\| last_cmd == LP_CATEGORY \|\| last_cmd == LP_URL))
3420	\|\| (category_out && last_cmd == LP_CATEGORY)
3421	)
3422	{
3423	long current_location = ftell(yylpin), i = string_start, quote = 0;
3424	char c;
3425	if (texinfo_out)
3426	{
3427	if (last_cmd == LP_INFO)
3428	{
3429	printf("$info = <<EOT;\n");
3430	}
3431	else if (last_cmd == LP_URL)
3432	{
3433	printf("$url = <<EOT;\n");
3434	}
3435	else
3436	{
3437	printf("$category = <<EOT;\n");
3438	}
3439	}
3440	fseek (yylpin, i, SEEK_SET);
3441	while (i< current_location)
3442	{
3443	c = fgetc(yylpin);
3444	if (c == '\\')
3445	{
3446	quote = (! quote);
3447	}
3448	else if (c == '"')
3449	{
3450	if (! quote) break;
3451	}
3452	else
3453	quote = 0;
3454	if (c == '@' \|\| c == '$') putchar('\\');
3455	if (c != '\r') putchar(c);
3456	i++;
3457	}
3458	if (category_out) exit(0);
3459	fseek (yylpin, current_location, SEEK_SET);
3460	printf("\nEOT\n");
3461	}
3462	#else
3463	if((last_cmd == LP_INFO)&&(mode == GET_INFO))
3464	{
3465	int i, offset=0;
3466	long current_location = ftell(yylpin);
3467	int len = (int)(current_pos(0) - string_start);
3468	fseek(yylpin, string_start, SEEK_SET);
3469	if (text_buffer!=NULL) omFree((ADDRESS)text_buffer);
3470	text_buffer = (char *)omAlloc(len+2);
3471	omMarkAsStaticAddr(text_buffer);
3472	myfread(text_buffer, len, 1, yylpin);
3473	fseek(yylpin, current_location, SEEK_SET);
3474	text_buffer[len]='\0';
3475	offset=0;
3476	for(i=0;i<=len; i++)
3477	{
3478	if(text_buffer[i]=='\\' &&
3479	(text_buffer[i+1]=='\"' \|\| text_buffer[i+1]=='{' \|\|
3480	text_buffer[i+1]=='}' \|\| text_buffer[i+1]=='\\'))
3481	{
3482	i++;
3483	offset++;
3484	}
3485	if(offset>0) text_buffer[i-offset] = text_buffer[i];
3486	}
3487	}
3488	#endif /* STANDALONE_PARSER */
3489	}
3490
3491	void print_init()
3492	{
3493	printf("Init=%d\n", yy_init);
3494	}
3495
3496	void print_version(lp_modes mode, char *p)
3497	{
3498	#ifdef STANDALONE_PARSER
3499	//printf("loading %s%s", p, libnamebuf);
3500	#else
3501	if ( mode == LOAD_LIB )
3502	{
3503	if (BVERBOSE(V_LOAD_LIB) && p!=NULL ) Print(" %s...", p);
3504	//Warn( "loading %s%s", p, libnamebuf);
3505	}
3506	#endif
3507	}
3508
3509	#ifdef STANDALONE_PARSER
3510	int main( int argc, char *argv[] )
3511	{
3512	lib_style_types lib_style;
3513	main_init(argc, argv);
3514	if(yyin == NULL)
3515	{
3516	fprintf(stderr, "No library found to parse.\n");
3517	return 1;
3518	}
3519	if (! (texinfo_out \|\| category_out))
3520	{
3521	if(lpverbose)printf("Verbose level=%d\n", lpverbose);
3522	if(check)printf("Reporting most possible annomalies.\n");
3523	if(lpverbose\|\|check)printf("\n");
3524
3525	printf( " %-15s %20s %s,%s %s,%s %s,%s\n", "Library",
3526	"function", "line", "start-eod", "line", "body-eob",
3527	"line", "example-eoe");
3528	}
3529	yylplex(argv[0], argv[0], &lib_style,NULL);
3530	if(yylp_errno)
3531	{
3532	printf("ERROR occured: [%d] ", yylp_errno);
3533	printf(yylp_errlist[yylp_errno], yylplineno);
3534	printf("\n");
3535	}
3536	else if(pi!=NULL) printpi(pi);
3537	if (texinfo_out)
3538	printf("1;");
3539	return 0;
3540	}
3541
3542	#endif /* STANDALONE_PARSER */
3543	#endif /* HAVE_LIBPARSE */

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

Download in other formats: