Context Navigation

source: git/Singular/libparse.cc @ ed07eb

spielwiese

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

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

Download in other formats: