Context Navigation

source: git/Singular/libparse.cc @ 8d1432e

spielwiese

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

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

Download in other formats: