Context Navigation

source: git/Singular/libparse.cc @ d3e630

spielwiese

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

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

Download in other formats: