Context Navigation

source: git/Singular/libparse.cc @ 72a01e

spielwiese

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

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

Download in other formats: