Context Navigation

source: git/Singular/libparse.cc @ b99f73

spielwiese

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

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

Download in other formats: