aboutsummaryrefslogtreecommitdiffstats
path: root/scripts/genksyms/lex.c_shipped
diff options
context:
space:
mode:
Diffstat (limited to 'scripts/genksyms/lex.c_shipped')
-rw-r--r--scripts/genksyms/lex.c_shipped1802
1 files changed, 1153 insertions, 649 deletions
diff --git a/scripts/genksyms/lex.c_shipped b/scripts/genksyms/lex.c_shipped
index 37ba98241b9..2a176988d46 100644
--- a/scripts/genksyms/lex.c_shipped
+++ b/scripts/genksyms/lex.c_shipped
@@ -1,32 +1,114 @@
1#line 2 "scripts/genksyms/lex.c" 1#line 2 "scripts/genksyms/lex.c"
2/* A lexical scanner generated by flex */
3 2
4/* Scanner skeleton version: 3#line 4 "scripts/genksyms/lex.c"
5 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ 4
6 */ 5#define YY_INT_ALIGNED short int
6
7/* A lexical scanner generated by flex */
7 8
8#define FLEX_SCANNER 9#define FLEX_SCANNER
9#define YY_FLEX_MAJOR_VERSION 2 10#define YY_FLEX_MAJOR_VERSION 2
10#define YY_FLEX_MINOR_VERSION 5 11#define YY_FLEX_MINOR_VERSION 5
12#define YY_FLEX_SUBMINOR_VERSION 33
13#if YY_FLEX_SUBMINOR_VERSION > 0
14#define FLEX_BETA
15#endif
16
17/* %if-c++-only */
18/* %endif */
11 19
20/* %if-c-only */
21
22/* %endif */
23
24/* %if-c-only */
25
26/* %endif */
27
28/* First, we deal with platform-specific or compiler-specific issues. */
29
30/* begin standard C headers. */
31/* %if-c-only */
12#include <stdio.h> 32#include <stdio.h>
13#include <unistd.h> 33#include <string.h>
34#include <errno.h>
35#include <stdlib.h>
36/* %endif */
14 37
38/* %if-tables-serialization */
39/* %endif */
40/* end standard C headers. */
15 41
16/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 42/* %if-c-or-c++ */
17#ifdef c_plusplus 43/* flex integer type definitions */
18#ifndef __cplusplus 44
19#define __cplusplus 45#ifndef FLEXINT_H
46#define FLEXINT_H
47
48/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
49
50#if __STDC_VERSION__ >= 199901L
51
52/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
53 * if you want the limit (max/min) macros for int types.
54 */
55#ifndef __STDC_LIMIT_MACROS
56#define __STDC_LIMIT_MACROS 1
57#endif
58
59#include <inttypes.h>
60typedef int8_t flex_int8_t;
61typedef uint8_t flex_uint8_t;
62typedef int16_t flex_int16_t;
63typedef uint16_t flex_uint16_t;
64typedef int32_t flex_int32_t;
65typedef uint32_t flex_uint32_t;
66#else
67typedef signed char flex_int8_t;
68typedef short int flex_int16_t;
69typedef int flex_int32_t;
70typedef unsigned char flex_uint8_t;
71typedef unsigned short int flex_uint16_t;
72typedef unsigned int flex_uint32_t;
73#endif /* ! C99 */
74
75/* Limits of integral types. */
76#ifndef INT8_MIN
77#define INT8_MIN (-128)
78#endif
79#ifndef INT16_MIN
80#define INT16_MIN (-32767-1)
81#endif
82#ifndef INT32_MIN
83#define INT32_MIN (-2147483647-1)
20#endif 84#endif
85#ifndef INT8_MAX
86#define INT8_MAX (127)
87#endif
88#ifndef INT16_MAX
89#define INT16_MAX (32767)
90#endif
91#ifndef INT32_MAX
92#define INT32_MAX (2147483647)
93#endif
94#ifndef UINT8_MAX
95#define UINT8_MAX (255U)
96#endif
97#ifndef UINT16_MAX
98#define UINT16_MAX (65535U)
99#endif
100#ifndef UINT32_MAX
101#define UINT32_MAX (4294967295U)
21#endif 102#endif
22 103
104#endif /* ! FLEXINT_H */
23 105
24#ifdef __cplusplus 106/* %endif */
25 107
26#include <stdlib.h> 108/* %if-c++-only */
109/* %endif */
27 110
28/* Use prototypes in function declarations. */ 111#ifdef __cplusplus
29#define YY_USE_PROTOS
30 112
31/* The "const" storage-class-modifier is valid. */ 113/* The "const" storage-class-modifier is valid. */
32#define YY_USE_CONST 114#define YY_USE_CONST
@@ -35,36 +117,24 @@
35 117
36#if __STDC__ 118#if __STDC__
37 119
38#define YY_USE_PROTOS
39#define YY_USE_CONST 120#define YY_USE_CONST
40 121
41#endif /* __STDC__ */ 122#endif /* __STDC__ */
42#endif /* ! __cplusplus */ 123#endif /* ! __cplusplus */
43 124
44#ifdef __TURBOC__
45 #pragma warn -rch
46 #pragma warn -use
47#include <io.h>
48#include <stdlib.h>
49#define YY_USE_CONST
50#define YY_USE_PROTOS
51#endif
52
53#ifdef YY_USE_CONST 125#ifdef YY_USE_CONST
54#define yyconst const 126#define yyconst const
55#else 127#else
56#define yyconst 128#define yyconst
57#endif 129#endif
58 130
59 131/* %not-for-header */
60#ifdef YY_USE_PROTOS
61#define YY_PROTO(proto) proto
62#else
63#define YY_PROTO(proto) ()
64#endif
65 132
66/* Returned upon end-of-file. */ 133/* Returned upon end-of-file. */
67#define YY_NULL 0 134#define YY_NULL 0
135/* %ok-for-header */
136
137/* %not-for-header */
68 138
69/* Promotes a possibly negative, possibly signed char to an unsigned 139/* Promotes a possibly negative, possibly signed char to an unsigned
70 * integer for use as an array index. If the signed char is negative, 140 * integer for use as an array index. If the signed char is negative,
@@ -72,79 +142,102 @@
72 * double cast. 142 * double cast.
73 */ 143 */
74#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 144#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
145/* %ok-for-header */
146
147/* %if-reentrant */
148/* %endif */
149
150/* %if-not-reentrant */
151
152/* %endif */
75 153
76/* Enter a start condition. This macro really ought to take a parameter, 154/* Enter a start condition. This macro really ought to take a parameter,
77 * but we do it the disgusting crufty way forced on us by the ()-less 155 * but we do it the disgusting crufty way forced on us by the ()-less
78 * definition of BEGIN. 156 * definition of BEGIN.
79 */ 157 */
80#define BEGIN yy_start = 1 + 2 * 158#define BEGIN (yy_start) = 1 + 2 *
81 159
82/* Translate the current start state into a value that can be later handed 160/* Translate the current start state into a value that can be later handed
83 * to BEGIN to return to the state. The YYSTATE alias is for lex 161 * to BEGIN to return to the state. The YYSTATE alias is for lex
84 * compatibility. 162 * compatibility.
85 */ 163 */
86#define YY_START ((yy_start - 1) / 2) 164#define YY_START (((yy_start) - 1) / 2)
87#define YYSTATE YY_START 165#define YYSTATE YY_START
88 166
89/* Action number for EOF rule of a given start state. */ 167/* Action number for EOF rule of a given start state. */
90#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 168#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
91 169
92/* Special action meaning "start processing a new file". */ 170/* Special action meaning "start processing a new file". */
93#define YY_NEW_FILE yyrestart( yyin ) 171#define YY_NEW_FILE yyrestart(yyin )
94 172
95#define YY_END_OF_BUFFER_CHAR 0 173#define YY_END_OF_BUFFER_CHAR 0
96 174
97/* Size of default input buffer. */ 175/* Size of default input buffer. */
176#ifndef YY_BUF_SIZE
98#define YY_BUF_SIZE 16384 177#define YY_BUF_SIZE 16384
178#endif
99 179
180/* The state buf must be large enough to hold one state per character in the main buffer.
181 */
182#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
183
184#ifndef YY_TYPEDEF_YY_BUFFER_STATE
185#define YY_TYPEDEF_YY_BUFFER_STATE
100typedef struct yy_buffer_state *YY_BUFFER_STATE; 186typedef struct yy_buffer_state *YY_BUFFER_STATE;
187#endif
101 188
189/* %if-not-reentrant */
102extern int yyleng; 190extern int yyleng;
191/* %endif */
192
193/* %if-c-only */
194/* %if-not-reentrant */
103extern FILE *yyin, *yyout; 195extern FILE *yyin, *yyout;
196/* %endif */
197/* %endif */
104 198
105#define EOB_ACT_CONTINUE_SCAN 0 199#define EOB_ACT_CONTINUE_SCAN 0
106#define EOB_ACT_END_OF_FILE 1 200#define EOB_ACT_END_OF_FILE 1
107#define EOB_ACT_LAST_MATCH 2 201#define EOB_ACT_LAST_MATCH 2
108 202
109/* The funky do-while in the following #define is used to turn the definition 203 #define YY_LESS_LINENO(n)
110 * int a single C statement (which needs a semi-colon terminator). This 204
111 * avoids problems with code like: 205/* Return all but the first "n" matched characters back to the input stream. */
112 *
113 * if ( condition_holds )
114 * yyless( 5 );
115 * else
116 * do_something_else();
117 *
118 * Prior to using the do-while the compiler would get upset at the
119 * "else" because it interpreted the "if" statement as being all
120 * done when it reached the ';' after the yyless() call.
121 */
122
123/* Return all but the first 'n' matched characters back to the input stream. */
124
125#define yyless(n) \ 206#define yyless(n) \
126 do \ 207 do \
127 { \ 208 { \
128 /* Undo effects of setting up yytext. */ \ 209 /* Undo effects of setting up yytext. */ \
129 *yy_cp = yy_hold_char; \ 210 int yyless_macro_arg = (n); \
211 YY_LESS_LINENO(yyless_macro_arg);\
212 *yy_cp = (yy_hold_char); \
130 YY_RESTORE_YY_MORE_OFFSET \ 213 YY_RESTORE_YY_MORE_OFFSET \
131 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 214 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
132 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 215 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
133 } \ 216 } \
134 while ( 0 ) 217 while ( 0 )
135 218
136#define unput(c) yyunput( c, yytext_ptr ) 219#define unput(c) yyunput( c, (yytext_ptr) )
137 220
138/* The following is because we cannot portably get our hands on size_t 221/* The following is because we cannot portably get our hands on size_t
139 * (without autoconf's help, which isn't available because we want 222 * (without autoconf's help, which isn't available because we want
140 * flex-generated scanners to compile on their own). 223 * flex-generated scanners to compile on their own).
141 */ 224 */
142typedef unsigned int yy_size_t;
143 225
226#ifndef YY_TYPEDEF_YY_SIZE_T
227#define YY_TYPEDEF_YY_SIZE_T
228typedef unsigned int yy_size_t;
229#endif
144 230
231#ifndef YY_STRUCT_YY_BUFFER_STATE
232#define YY_STRUCT_YY_BUFFER_STATE
145struct yy_buffer_state 233struct yy_buffer_state
146 { 234 {
235/* %if-c-only */
147 FILE *yy_input_file; 236 FILE *yy_input_file;
237/* %endif */
238
239/* %if-c++-only */
240/* %endif */
148 241
149 char *yy_ch_buf; /* input buffer */ 242 char *yy_ch_buf; /* input buffer */
150 char *yy_buf_pos; /* current position in input buffer */ 243 char *yy_buf_pos; /* current position in input buffer */
@@ -178,12 +271,16 @@ struct yy_buffer_state
178 */ 271 */
179 int yy_at_bol; 272 int yy_at_bol;
180 273
274 int yy_bs_lineno; /**< The line count. */
275 int yy_bs_column; /**< The column count. */
276
181 /* Whether to try to fill the input buffer when we reach the 277 /* Whether to try to fill the input buffer when we reach the
182 * end of it. 278 * end of it.
183 */ 279 */
184 int yy_fill_buffer; 280 int yy_fill_buffer;
185 281
186 int yy_buffer_status; 282 int yy_buffer_status;
283
187#define YY_BUFFER_NEW 0 284#define YY_BUFFER_NEW 0
188#define YY_BUFFER_NORMAL 1 285#define YY_BUFFER_NORMAL 1
189 /* When an EOF's been seen but there's still some text to process 286 /* When an EOF's been seen but there's still some text to process
@@ -197,102 +294,163 @@ struct yy_buffer_state
197 * just pointing yyin at a new input file. 294 * just pointing yyin at a new input file.
198 */ 295 */
199#define YY_BUFFER_EOF_PENDING 2 296#define YY_BUFFER_EOF_PENDING 2
297
200 }; 298 };
299#endif /* !YY_STRUCT_YY_BUFFER_STATE */
300
301/* %if-c-only Standard (non-C++) definition */
302/* %not-for-header */
201 303
202static YY_BUFFER_STATE yy_current_buffer = 0; 304/* %if-not-reentrant */
305
306/* Stack of input buffers. */
307static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
308static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
309static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
310/* %endif */
311/* %ok-for-header */
312
313/* %endif */
203 314
204/* We provide macros for accessing buffer states in case in the 315/* We provide macros for accessing buffer states in case in the
205 * future we want to put the buffer states in a more general 316 * future we want to put the buffer states in a more general
206 * "scanner state". 317 * "scanner state".
318 *
319 * Returns the top of the stack, or NULL.
207 */ 320 */
208#define YY_CURRENT_BUFFER yy_current_buffer 321#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
322 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
323 : NULL)
209 324
325/* Same as previous macro, but useful when we know that the buffer stack is not
326 * NULL or when we need an lvalue. For internal use only.
327 */
328#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
329
330/* %if-c-only Standard (non-C++) definition */
331
332/* %if-not-reentrant */
333/* %not-for-header */
210 334
211/* yy_hold_char holds the character lost when yytext is formed. */ 335/* yy_hold_char holds the character lost when yytext is formed. */
212static char yy_hold_char; 336static char yy_hold_char;
213
214static int yy_n_chars; /* number of characters read into yy_ch_buf */ 337static int yy_n_chars; /* number of characters read into yy_ch_buf */
215
216
217int yyleng; 338int yyleng;
218 339
219/* Points to current character in buffer. */ 340/* Points to current character in buffer. */
220static char *yy_c_buf_p = (char *) 0; 341static char *yy_c_buf_p = (char *) 0;
221static int yy_init = 1; /* whether we need to initialize */ 342static int yy_init = 0; /* whether we need to initialize */
222static int yy_start = 0; /* start state number */ 343static int yy_start = 0; /* start state number */
223 344
224/* Flag which is used to allow yywrap()'s to do buffer switches 345/* Flag which is used to allow yywrap()'s to do buffer switches
225 * instead of setting up a fresh yyin. A bit of a hack ... 346 * instead of setting up a fresh yyin. A bit of a hack ...
226 */ 347 */
227static int yy_did_buffer_switch_on_eof; 348static int yy_did_buffer_switch_on_eof;
349/* %ok-for-header */
350
351/* %endif */
228 352
229void yyrestart YY_PROTO(( FILE *input_file )); 353void yyrestart (FILE *input_file );
354void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
355YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
356void yy_delete_buffer (YY_BUFFER_STATE b );
357void yy_flush_buffer (YY_BUFFER_STATE b );
358void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
359void yypop_buffer_state (void );
230 360
231void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 361static void yyensure_buffer_stack (void );
232void yy_load_buffer_state YY_PROTO(( void )); 362static void yy_load_buffer_state (void );
233YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 363static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
234void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
235void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
236void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
237#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
238 364
239YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 365#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
240YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
241YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
242 366
243static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 367YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
244static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 368YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
245static void yy_flex_free YY_PROTO(( void * )); 369YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len );
370
371/* %endif */
372
373void *yyalloc (yy_size_t );
374void *yyrealloc (void *,yy_size_t );
375void yyfree (void * );
246 376
247#define yy_new_buffer yy_create_buffer 377#define yy_new_buffer yy_create_buffer
248 378
249#define yy_set_interactive(is_interactive) \ 379#define yy_set_interactive(is_interactive) \
250 { \ 380 { \
251 if ( ! yy_current_buffer ) \ 381 if ( ! YY_CURRENT_BUFFER ){ \
252 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 382 yyensure_buffer_stack (); \
253 yy_current_buffer->yy_is_interactive = is_interactive; \ 383 YY_CURRENT_BUFFER_LVALUE = \
384 yy_create_buffer(yyin,YY_BUF_SIZE ); \
385 } \
386 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
254 } 387 }
255 388
256#define yy_set_bol(at_bol) \ 389#define yy_set_bol(at_bol) \
257 { \ 390 { \
258 if ( ! yy_current_buffer ) \ 391 if ( ! YY_CURRENT_BUFFER ){\
259 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 392 yyensure_buffer_stack (); \
260 yy_current_buffer->yy_at_bol = at_bol; \ 393 YY_CURRENT_BUFFER_LVALUE = \
394 yy_create_buffer(yyin,YY_BUF_SIZE ); \
395 } \
396 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
261 } 397 }
262 398
263#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 399#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
264 400
401/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
402/* Begin user sect3 */
265 403
266#define yywrap() 1 404#define yywrap() 1
267#define YY_SKIP_YYWRAP 405#define YY_SKIP_YYWRAP
268 406
269#define FLEX_DEBUG 407#define FLEX_DEBUG
408
270typedef unsigned char YY_CHAR; 409typedef unsigned char YY_CHAR;
410
271FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 411FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
412
272typedef int yy_state_type; 413typedef int yy_state_type;
273 414
274#define FLEX_DEBUG 415extern int yylineno;
416
417int yylineno = 1;
418
275extern char *yytext; 419extern char *yytext;
276#define yytext_ptr yytext 420#define yytext_ptr yytext
277 421
278static yy_state_type yy_get_previous_state YY_PROTO(( void )); 422/* %if-c-only Standard (non-C++) definition */
279static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 423
280static int yy_get_next_buffer YY_PROTO(( void )); 424static yy_state_type yy_get_previous_state (void );
281static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 425static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
426static int yy_get_next_buffer (void );
427static void yy_fatal_error (yyconst char msg[] );
428
429/* %endif */
282 430
283/* Done after the current pattern has been matched and before the 431/* Done after the current pattern has been matched and before the
284 * corresponding action - sets up yytext. 432 * corresponding action - sets up yytext.
285 */ 433 */
286#define YY_DO_BEFORE_ACTION \ 434#define YY_DO_BEFORE_ACTION \
287 yytext_ptr = yy_bp; \ 435 (yytext_ptr) = yy_bp; \
288 yyleng = (int) (yy_cp - yy_bp); \ 436/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
289 yy_hold_char = *yy_cp; \ 437 yyleng = (size_t) (yy_cp - yy_bp); \
438 (yy_hold_char) = *yy_cp; \
290 *yy_cp = '\0'; \ 439 *yy_cp = '\0'; \
291 yy_c_buf_p = yy_cp; 440/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
441 (yy_c_buf_p) = yy_cp;
292 442
443/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
293#define YY_NUM_RULES 13 444#define YY_NUM_RULES 13
294#define YY_END_OF_BUFFER 14 445#define YY_END_OF_BUFFER 14
295static yyconst short int yy_accept[76] = 446/* This struct is not used in this scanner,
447 but its presence is necessary. */
448struct yy_trans_info
449 {
450 flex_int32_t yy_verify;
451 flex_int32_t yy_nxt;
452 };
453static yyconst flex_int16_t yy_accept[76] =
296 { 0, 454 { 0,
297 0, 0, 0, 0, 14, 12, 4, 3, 12, 7, 455 0, 0, 0, 0, 14, 12, 4, 3, 12, 7,
298 12, 12, 7, 12, 12, 12, 12, 12, 9, 9, 456 12, 12, 7, 12, 12, 12, 12, 12, 9, 9,
@@ -304,7 +462,7 @@ static yyconst short int yy_accept[76] =
304 0, 0, 0, 1, 0 462 0, 0, 0, 1, 0
305 } ; 463 } ;
306 464
307static yyconst int yy_ec[256] = 465static yyconst flex_int32_t yy_ec[256] =
308 { 0, 466 { 0,
309 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 467 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
310 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 468 4, 4, 4, 1, 1, 1, 1, 1, 1, 1,
@@ -336,14 +494,14 @@ static yyconst int yy_ec[256] =
336 1, 1, 1, 1, 1 494 1, 1, 1, 1, 1
337 } ; 495 } ;
338 496
339static yyconst int yy_meta[29] = 497static yyconst flex_int32_t yy_meta[29] =
340 { 0, 498 { 0,
341 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 499 1, 1, 2, 1, 1, 1, 3, 1, 1, 1,
342 4, 4, 5, 6, 6, 6, 1, 1, 1, 7, 500 4, 4, 5, 6, 6, 6, 1, 1, 1, 7,
343 8, 7, 3, 3, 3, 1, 3, 1 501 8, 7, 3, 3, 3, 1, 3, 1
344 } ; 502 } ;
345 503
346static yyconst short int yy_base[88] = 504static yyconst flex_int16_t yy_base[88] =
347 { 0, 505 { 0,
348 0, 147, 21, 140, 145, 284, 39, 284, 26, 0, 506 0, 147, 21, 140, 145, 284, 39, 284, 26, 0,
349 32, 126, 40, 44, 115, 35, 36, 46, 50, 53, 507 32, 126, 40, 44, 115, 35, 36, 46, 50, 53,
@@ -356,7 +514,7 @@ static yyconst short int yy_base[88] =
356 246, 250, 255, 256, 261, 267, 275 514 246, 250, 255, 256, 261, 267, 275
357 } ; 515 } ;
358 516
359static yyconst short int yy_def[88] = 517static yyconst flex_int16_t yy_def[88] =
360 { 0, 518 { 0,
361 75, 1, 1, 3, 75, 75, 75, 75, 76, 77, 519 75, 1, 1, 3, 75, 75, 75, 75, 76, 77,
362 78, 75, 77, 79, 75, 75, 75, 75, 75, 19, 520 78, 75, 77, 79, 75, 75, 75, 75, 75, 19,
@@ -369,7 +527,7 @@ static yyconst short int yy_def[88] =
369 75, 75, 75, 75, 75, 75, 75 527 75, 75, 75, 75, 75, 75, 75
370 } ; 528 } ;
371 529
372static yyconst short int yy_nxt[313] = 530static yyconst flex_int16_t yy_nxt[313] =
373 { 0, 531 { 0,
374 6, 7, 8, 7, 9, 6, 10, 6, 6, 11, 532 6, 7, 8, 7, 9, 6, 10, 6, 6, 11,
375 6, 6, 12, 6, 6, 6, 6, 6, 6, 10, 533 6, 6, 12, 6, 6, 6, 6, 6, 6, 10,
@@ -408,7 +566,7 @@ static yyconst short int yy_nxt[313] =
408 75, 75 566 75, 75
409 } ; 567 } ;
410 568
411static yyconst short int yy_chk[313] = 569static yyconst flex_int16_t yy_chk[313] =
412 { 0, 570 { 0,
413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 571 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 572 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -453,7 +611,7 @@ static char *yy_last_accepting_cpos;
453extern int yy_flex_debug; 611extern int yy_flex_debug;
454int yy_flex_debug = 1; 612int yy_flex_debug = 1;
455 613
456static yyconst short int yy_rule_linenum[13] = 614static yyconst flex_int16_t yy_rule_linenum[13] =
457 { 0, 615 { 0,
458 69, 70, 71, 74, 77, 78, 79, 85, 86, 87, 616 69, 70, 71, 74, 77, 78, 79, 85, 86, 87,
459 89, 92 617 89, 92
@@ -468,7 +626,6 @@ static yyconst short int yy_rule_linenum[13] =
468#define YY_RESTORE_YY_MORE_OFFSET 626#define YY_RESTORE_YY_MORE_OFFSET
469char *yytext; 627char *yytext;
470#line 1 "scripts/genksyms/lex.l" 628#line 1 "scripts/genksyms/lex.l"
471#define INITIAL 0
472/* Lexical analysis for genksyms. 629/* Lexical analysis for genksyms.
473 Copyright 1996, 1997 Linux International. 630 Copyright 1996, 1997 Linux International.
474 631
@@ -506,10 +663,41 @@ char *yytext;
506 663
507/* Version 2 checksumming does proper tokenization; version 1 wasn't 664/* Version 2 checksumming does proper tokenization; version 1 wasn't
508 quite so pedantic. */ 665 quite so pedantic. */
509#define V2_TOKENS 1
510 666
511/* We don't do multiple input files. */ 667/* We don't do multiple input files. */
512#line 513 "scripts/genksyms/lex.c" 668#line 669 "scripts/genksyms/lex.c"
669
670#define INITIAL 0
671#define V2_TOKENS 1
672
673#ifndef YY_NO_UNISTD_H
674/* Special case for "unistd.h", since it is non-ANSI. We include it way
675 * down here because we want the user's section 1 to have been scanned first.
676 * The user has a chance to override it with an option.
677 */
678/* %if-c-only */
679#include <unistd.h>
680/* %endif */
681/* %if-c++-only */
682/* %endif */
683#endif
684
685#ifndef YY_EXTRA_TYPE
686#define YY_EXTRA_TYPE void *
687#endif
688
689/* %if-c-only Reentrant structure and macros (non-C++). */
690/* %if-reentrant */
691/* %if-c-only */
692
693static int yy_init_globals (void );
694
695/* %endif */
696/* %if-reentrant */
697/* %endif */
698/* %if-bison-bridge */
699/* %endif */
700/* %endif End reentrant structures and macros. */
513 701
514/* Macros after this point can all be overridden by user definitions in 702/* Macros after this point can all be overridden by user definitions in
515 * section 1. 703 * section 1.
@@ -517,66 +705,45 @@ char *yytext;
517 705
518#ifndef YY_SKIP_YYWRAP 706#ifndef YY_SKIP_YYWRAP
519#ifdef __cplusplus 707#ifdef __cplusplus
520extern "C" int yywrap YY_PROTO(( void )); 708extern "C" int yywrap (void );
521#else 709#else
522extern int yywrap YY_PROTO(( void )); 710extern int yywrap (void );
523#endif 711#endif
524#endif 712#endif
525 713
526#ifndef YY_NO_UNPUT 714/* %not-for-header */
527static void yyunput YY_PROTO(( int c, char *buf_ptr )); 715
528#endif 716 static void yyunput (int c,char *buf_ptr );
717
718/* %ok-for-header */
719
720/* %endif */
529 721
530#ifndef yytext_ptr 722#ifndef yytext_ptr
531static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 723static void yy_flex_strncpy (char *,yyconst char *,int );
532#endif 724#endif
533 725
534#ifdef YY_NEED_STRLEN 726#ifdef YY_NEED_STRLEN
535static int yy_flex_strlen YY_PROTO(( yyconst char * )); 727static int yy_flex_strlen (yyconst char * );
536#endif 728#endif
537 729
538#ifndef YY_NO_INPUT 730#ifndef YY_NO_INPUT
731/* %if-c-only Standard (non-C++) definition */
732/* %not-for-header */
733
539#ifdef __cplusplus 734#ifdef __cplusplus
540static int yyinput YY_PROTO(( void )); 735static int yyinput (void );
541#else 736#else
542static int input YY_PROTO(( void )); 737static int input (void );
543#endif
544#endif 738#endif
739/* %ok-for-header */
545 740
546#if YY_STACK_USED 741/* %endif */
547static int yy_start_stack_ptr = 0;
548static int yy_start_stack_depth = 0;
549static int *yy_start_stack = 0;
550#ifndef YY_NO_PUSH_STATE
551static void yy_push_state YY_PROTO(( int new_state ));
552#endif
553#ifndef YY_NO_POP_STATE
554static void yy_pop_state YY_PROTO(( void ));
555#endif
556#ifndef YY_NO_TOP_STATE
557static int yy_top_state YY_PROTO(( void ));
558#endif 742#endif
559 743
560#else 744/* %if-c-only */
561#define YY_NO_PUSH_STATE 1
562#define YY_NO_POP_STATE 1
563#define YY_NO_TOP_STATE 1
564#endif
565 745
566#ifdef YY_MALLOC_DECL 746/* %endif */
567YY_MALLOC_DECL
568#else
569#if __STDC__
570#ifndef __cplusplus
571#include <stdlib.h>
572#endif
573#else
574/* Just try to get by without declaring the routines. This will fail
575 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
576 * or sizeof(void*) != sizeof(int).
577 */
578#endif
579#endif
580 747
581/* Amount of stuff to slurp up with each read. */ 748/* Amount of stuff to slurp up with each read. */
582#ifndef YY_READ_BUF_SIZE 749#ifndef YY_READ_BUF_SIZE
@@ -584,12 +751,15 @@ YY_MALLOC_DECL
584#endif 751#endif
585 752
586/* Copy whatever the last rule matched to the standard output. */ 753/* Copy whatever the last rule matched to the standard output. */
587
588#ifndef ECHO 754#ifndef ECHO
755/* %if-c-only Standard (non-C++) definition */
589/* This used to be an fputs(), but since the string might contain NUL's, 756/* This used to be an fputs(), but since the string might contain NUL's,
590 * we now use fwrite(). 757 * we now use fwrite().
591 */ 758 */
592#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 759#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
760/* %endif */
761/* %if-c++-only C++ definition */
762/* %endif */
593#endif 763#endif
594 764
595/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 765/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
@@ -597,9 +767,11 @@ YY_MALLOC_DECL
597 */ 767 */
598#ifndef YY_INPUT 768#ifndef YY_INPUT
599#define YY_INPUT(buf,result,max_size) \ 769#define YY_INPUT(buf,result,max_size) \
600 if ( yy_current_buffer->yy_is_interactive ) \ 770/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
771 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
601 { \ 772 { \
602 int c = '*', n; \ 773 int c = '*'; \
774 size_t n; \
603 for ( n = 0; n < max_size && \ 775 for ( n = 0; n < max_size && \
604 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 776 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
605 buf[n] = (char) c; \ 777 buf[n] = (char) c; \
@@ -609,9 +781,24 @@ YY_MALLOC_DECL
609 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 781 YY_FATAL_ERROR( "input in flex scanner failed" ); \
610 result = n; \ 782 result = n; \
611 } \ 783 } \
612 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 784 else \
613 && ferror( yyin ) ) \ 785 { \
614 YY_FATAL_ERROR( "input in flex scanner failed" ); 786 errno=0; \
787 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
788 { \
789 if( errno != EINTR) \
790 { \
791 YY_FATAL_ERROR( "input in flex scanner failed" ); \
792 break; \
793 } \
794 errno=0; \
795 clearerr(yyin); \
796 } \
797 }\
798\
799/* %if-c++-only C++ definition \ */\
800/* %endif */
801
615#endif 802#endif
616 803
617/* No semi-colon after return; correct usage is to write "yyterminate();" - 804/* No semi-colon after return; correct usage is to write "yyterminate();" -
@@ -629,15 +816,40 @@ YY_MALLOC_DECL
629 816
630/* Report a fatal error. */ 817/* Report a fatal error. */
631#ifndef YY_FATAL_ERROR 818#ifndef YY_FATAL_ERROR
819/* %if-c-only */
632#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 820#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
821/* %endif */
822/* %if-c++-only */
823/* %endif */
633#endif 824#endif
634 825
826/* %if-tables-serialization structures and prototypes */
827/* %not-for-header */
828
829/* %ok-for-header */
830
831/* %not-for-header */
832
833/* %tables-yydmap generated elements */
834/* %endif */
835/* end tables serialization structures and prototypes */
836
837/* %ok-for-header */
838
635/* Default declaration of generated scanner - a define so the user can 839/* Default declaration of generated scanner - a define so the user can
636 * easily add parameters. 840 * easily add parameters.
637 */ 841 */
638#ifndef YY_DECL 842#ifndef YY_DECL
639#define YY_DECL int yylex YY_PROTO(( void )) 843#define YY_DECL_IS_OURS 1
640#endif 844/* %if-c-only Standard (non-C++) definition */
845
846extern int yylex (void);
847
848#define YY_DECL int yylex (void)
849/* %endif */
850/* %if-c++-only C++ definition */
851/* %endif */
852#endif /* !YY_DECL */
641 853
642/* Code executed at the beginning of each rule, after yytext and yyleng 854/* Code executed at the beginning of each rule, after yytext and yyleng
643 * have been set up. 855 * have been set up.
@@ -651,62 +863,80 @@ YY_MALLOC_DECL
651#define YY_BREAK break; 863#define YY_BREAK break;
652#endif 864#endif
653 865
866/* %% [6.0] YY_RULE_SETUP definition goes here */
654#define YY_RULE_SETUP \ 867#define YY_RULE_SETUP \
655 if ( yyleng > 0 ) \ 868 if ( yyleng > 0 ) \
656 yy_current_buffer->yy_at_bol = \ 869 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
657 (yytext[yyleng - 1] == '\n'); \ 870 (yytext[yyleng - 1] == '\n'); \
658 YY_USER_ACTION 871 YY_USER_ACTION
659 872
873/* %not-for-header */
874
875/** The main scanner function which does all the work.
876 */
660YY_DECL 877YY_DECL
661 { 878{
662 register yy_state_type yy_current_state; 879 register yy_state_type yy_current_state;
663 register char *yy_cp = NULL, *yy_bp = NULL; 880 register char *yy_cp, *yy_bp;
664 register int yy_act; 881 register int yy_act;
665 882
883/* %% [7.0] user's declarations go here */
666#line 65 "scripts/genksyms/lex.l" 884#line 65 "scripts/genksyms/lex.l"
667 885
668 886
669 887
670 /* Keep track of our location in the original source files. */ 888 /* Keep track of our location in the original source files. */
671#line 672 "scripts/genksyms/lex.c" 889#line 890 "scripts/genksyms/lex.c"
672 890
673 if ( yy_init ) 891 if ( !(yy_init) )
674 { 892 {
675 yy_init = 0; 893 (yy_init) = 1;
676 894
677#ifdef YY_USER_INIT 895#ifdef YY_USER_INIT
678 YY_USER_INIT; 896 YY_USER_INIT;
679#endif 897#endif
680 898
681 if ( ! yy_start ) 899 if ( ! (yy_start) )
682 yy_start = 1; /* first start state */ 900 (yy_start) = 1; /* first start state */
683 901
684 if ( ! yyin ) 902 if ( ! yyin )
903/* %if-c-only */
685 yyin = stdin; 904 yyin = stdin;
905/* %endif */
906/* %if-c++-only */
907/* %endif */
686 908
687 if ( ! yyout ) 909 if ( ! yyout )
910/* %if-c-only */
688 yyout = stdout; 911 yyout = stdout;
912/* %endif */
913/* %if-c++-only */
914/* %endif */
915
916 if ( ! YY_CURRENT_BUFFER ) {
917 yyensure_buffer_stack ();
918 YY_CURRENT_BUFFER_LVALUE =
919 yy_create_buffer(yyin,YY_BUF_SIZE );
920 }
689 921
690 if ( ! yy_current_buffer ) 922 yy_load_buffer_state( );
691 yy_current_buffer =
692 yy_create_buffer( yyin, YY_BUF_SIZE );
693
694 yy_load_buffer_state();
695 } 923 }
696 924
697 while ( 1 ) /* loops until end-of-file is reached */ 925 while ( 1 ) /* loops until end-of-file is reached */
698 { 926 {
699 yy_cp = yy_c_buf_p; 927/* %% [8.0] yymore()-related code goes here */
928 yy_cp = (yy_c_buf_p);
700 929
701 /* Support of yytext. */ 930 /* Support of yytext. */
702 *yy_cp = yy_hold_char; 931 *yy_cp = (yy_hold_char);
703 932
704 /* yy_bp points to the position in yy_ch_buf of the start of 933 /* yy_bp points to the position in yy_ch_buf of the start of
705 * the current run. 934 * the current run.
706 */ 935 */
707 yy_bp = yy_cp; 936 yy_bp = yy_cp;
708 937
709 yy_current_state = yy_start; 938/* %% [9.0] code to set up and find next match goes here */
939 yy_current_state = (yy_start);
710 yy_current_state += YY_AT_BOL(); 940 yy_current_state += YY_AT_BOL();
711yy_match: 941yy_match:
712 do 942 do
@@ -714,8 +944,8 @@ yy_match:
714 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 944 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
715 if ( yy_accept[yy_current_state] ) 945 if ( yy_accept[yy_current_state] )
716 { 946 {
717 yy_last_accepting_state = yy_current_state; 947 (yy_last_accepting_state) = yy_current_state;
718 yy_last_accepting_cpos = yy_cp; 948 (yy_last_accepting_cpos) = yy_cp;
719 } 949 }
720 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 950 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
721 { 951 {
@@ -729,26 +959,29 @@ yy_match:
729 while ( yy_base[yy_current_state] != 284 ); 959 while ( yy_base[yy_current_state] != 284 );
730 960
731yy_find_action: 961yy_find_action:
962/* %% [10.0] code to find the action number goes here */
732 yy_act = yy_accept[yy_current_state]; 963 yy_act = yy_accept[yy_current_state];
733 if ( yy_act == 0 ) 964 if ( yy_act == 0 )
734 { /* have to back up */ 965 { /* have to back up */
735 yy_cp = yy_last_accepting_cpos; 966 yy_cp = (yy_last_accepting_cpos);
736 yy_current_state = yy_last_accepting_state; 967 yy_current_state = (yy_last_accepting_state);
737 yy_act = yy_accept[yy_current_state]; 968 yy_act = yy_accept[yy_current_state];
738 } 969 }
739 970
740 YY_DO_BEFORE_ACTION; 971 YY_DO_BEFORE_ACTION;
741 972
973/* %% [11.0] code for yylineno update goes here */
742 974
743do_action: /* This label is used only to access EOF actions. */ 975do_action: /* This label is used only to access EOF actions. */
744 976
977/* %% [12.0] debug code goes here */
745 if ( yy_flex_debug ) 978 if ( yy_flex_debug )
746 { 979 {
747 if ( yy_act == 0 ) 980 if ( yy_act == 0 )
748 fprintf( stderr, "--scanner backing up\n" ); 981 fprintf( stderr, "--scanner backing up\n" );
749 else if ( yy_act < 13 ) 982 else if ( yy_act < 13 )
750 fprintf( stderr, "--accepting rule at line %d (\"%s\")\n", 983 fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
751 yy_rule_linenum[yy_act], yytext ); 984 (long)yy_rule_linenum[yy_act], yytext );
752 else if ( yy_act == 13 ) 985 else if ( yy_act == 13 )
753 fprintf( stderr, "--accepting default rule (\"%s\")\n", 986 fprintf( stderr, "--accepting default rule (\"%s\")\n",
754 yytext ); 987 yytext );
@@ -760,24 +993,28 @@ do_action: /* This label is used only to access EOF actions. */
760 993
761 switch ( yy_act ) 994 switch ( yy_act )
762 { /* beginning of action switch */ 995 { /* beginning of action switch */
996/* %% [13.0] actions go here */
763 case 0: /* must back up */ 997 case 0: /* must back up */
764 /* undo the effects of YY_DO_BEFORE_ACTION */ 998 /* undo the effects of YY_DO_BEFORE_ACTION */
765 *yy_cp = yy_hold_char; 999 *yy_cp = (yy_hold_char);
766 yy_cp = yy_last_accepting_cpos; 1000 yy_cp = (yy_last_accepting_cpos);
767 yy_current_state = yy_last_accepting_state; 1001 yy_current_state = (yy_last_accepting_state);
768 goto yy_find_action; 1002 goto yy_find_action;
769 1003
770case 1: 1004case 1:
1005/* rule 1 can match eol */
771YY_RULE_SETUP 1006YY_RULE_SETUP
772#line 69 "scripts/genksyms/lex.l" 1007#line 69 "scripts/genksyms/lex.l"
773return FILENAME; 1008return FILENAME;
774 YY_BREAK 1009 YY_BREAK
775case 2: 1010case 2:
1011/* rule 2 can match eol */
776YY_RULE_SETUP 1012YY_RULE_SETUP
777#line 70 "scripts/genksyms/lex.l" 1013#line 70 "scripts/genksyms/lex.l"
778cur_line++; 1014cur_line++;
779 YY_BREAK 1015 YY_BREAK
780case 3: 1016case 3:
1017/* rule 3 can match eol */
781YY_RULE_SETUP 1018YY_RULE_SETUP
782#line 71 "scripts/genksyms/lex.l" 1019#line 71 "scripts/genksyms/lex.l"
783cur_line++; 1020cur_line++;
@@ -789,11 +1026,13 @@ YY_RULE_SETUP
789; 1026;
790 YY_BREAK 1027 YY_BREAK
791case 5: 1028case 5:
1029/* rule 5 can match eol */
792YY_RULE_SETUP 1030YY_RULE_SETUP
793#line 77 "scripts/genksyms/lex.l" 1031#line 77 "scripts/genksyms/lex.l"
794return STRING; 1032return STRING;
795 YY_BREAK 1033 YY_BREAK
796case 6: 1034case 6:
1035/* rule 6 can match eol */
797YY_RULE_SETUP 1036YY_RULE_SETUP
798#line 78 "scripts/genksyms/lex.l" 1037#line 78 "scripts/genksyms/lex.l"
799return CHAR; 1038return CHAR;
@@ -838,7 +1077,7 @@ YY_RULE_SETUP
838#line 95 "scripts/genksyms/lex.l" 1077#line 95 "scripts/genksyms/lex.l"
839ECHO; 1078ECHO;
840 YY_BREAK 1079 YY_BREAK
841#line 842 "scripts/genksyms/lex.c" 1080#line 1081 "scripts/genksyms/lex.c"
842case YY_STATE_EOF(INITIAL): 1081case YY_STATE_EOF(INITIAL):
843case YY_STATE_EOF(V2_TOKENS): 1082case YY_STATE_EOF(V2_TOKENS):
844 yyterminate(); 1083 yyterminate();
@@ -846,26 +1085,26 @@ case YY_STATE_EOF(V2_TOKENS):
846 case YY_END_OF_BUFFER: 1085 case YY_END_OF_BUFFER:
847 { 1086 {
848 /* Amount of text matched not including the EOB char. */ 1087 /* Amount of text matched not including the EOB char. */
849 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1088 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
850 1089
851 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1090 /* Undo the effects of YY_DO_BEFORE_ACTION. */
852 *yy_cp = yy_hold_char; 1091 *yy_cp = (yy_hold_char);
853 YY_RESTORE_YY_MORE_OFFSET 1092 YY_RESTORE_YY_MORE_OFFSET
854 1093
855 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1094 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
856 { 1095 {
857 /* We're scanning a new file or input source. It's 1096 /* We're scanning a new file or input source. It's
858 * possible that this happened because the user 1097 * possible that this happened because the user
859 * just pointed yyin at a new source and called 1098 * just pointed yyin at a new source and called
860 * yylex(). If so, then we have to assure 1099 * yylex(). If so, then we have to assure
861 * consistency between yy_current_buffer and our 1100 * consistency between YY_CURRENT_BUFFER and our
862 * globals. Here is the right place to do so, because 1101 * globals. Here is the right place to do so, because
863 * this is the first action (other than possibly a 1102 * this is the first action (other than possibly a
864 * back-up) that will match for the new input source. 1103 * back-up) that will match for the new input source.
865 */ 1104 */
866 yy_n_chars = yy_current_buffer->yy_n_chars; 1105 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
867 yy_current_buffer->yy_input_file = yyin; 1106 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
868 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1107 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
869 } 1108 }
870 1109
871 /* Note that here we test for yy_c_buf_p "<=" to the position 1110 /* Note that here we test for yy_c_buf_p "<=" to the position
@@ -875,13 +1114,13 @@ case YY_STATE_EOF(V2_TOKENS):
875 * end-of-buffer state). Contrast this with the test 1114 * end-of-buffer state). Contrast this with the test
876 * in input(). 1115 * in input().
877 */ 1116 */
878 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1117 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
879 { /* This was really a NUL. */ 1118 { /* This was really a NUL. */
880 yy_state_type yy_next_state; 1119 yy_state_type yy_next_state;
881 1120
882 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1121 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
883 1122
884 yy_current_state = yy_get_previous_state(); 1123 yy_current_state = yy_get_previous_state( );
885 1124
886 /* Okay, we're now positioned to make the NUL 1125 /* Okay, we're now positioned to make the NUL
887 * transition. We couldn't have 1126 * transition. We couldn't have
@@ -894,30 +1133,31 @@ case YY_STATE_EOF(V2_TOKENS):
894 1133
895 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1134 yy_next_state = yy_try_NUL_trans( yy_current_state );
896 1135
897 yy_bp = yytext_ptr + YY_MORE_ADJ; 1136 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
898 1137
899 if ( yy_next_state ) 1138 if ( yy_next_state )
900 { 1139 {
901 /* Consume the NUL. */ 1140 /* Consume the NUL. */
902 yy_cp = ++yy_c_buf_p; 1141 yy_cp = ++(yy_c_buf_p);
903 yy_current_state = yy_next_state; 1142 yy_current_state = yy_next_state;
904 goto yy_match; 1143 goto yy_match;
905 } 1144 }
906 1145
907 else 1146 else
908 { 1147 {
909 yy_cp = yy_c_buf_p; 1148/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
1149 yy_cp = (yy_c_buf_p);
910 goto yy_find_action; 1150 goto yy_find_action;
911 } 1151 }
912 } 1152 }
913 1153
914 else switch ( yy_get_next_buffer() ) 1154 else switch ( yy_get_next_buffer( ) )
915 { 1155 {
916 case EOB_ACT_END_OF_FILE: 1156 case EOB_ACT_END_OF_FILE:
917 { 1157 {
918 yy_did_buffer_switch_on_eof = 0; 1158 (yy_did_buffer_switch_on_eof) = 0;
919 1159
920 if ( yywrap() ) 1160 if ( yywrap( ) )
921 { 1161 {
922 /* Note: because we've taken care in 1162 /* Note: because we've taken care in
923 * yy_get_next_buffer() to have set up 1163 * yy_get_next_buffer() to have set up
@@ -928,7 +1168,7 @@ case YY_STATE_EOF(V2_TOKENS):
928 * YY_NULL, it'll still work - another 1168 * YY_NULL, it'll still work - another
929 * YY_NULL will get returned. 1169 * YY_NULL will get returned.
930 */ 1170 */
931 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1171 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
932 1172
933 yy_act = YY_STATE_EOF(YY_START); 1173 yy_act = YY_STATE_EOF(YY_START);
934 goto do_action; 1174 goto do_action;
@@ -936,30 +1176,30 @@ case YY_STATE_EOF(V2_TOKENS):
936 1176
937 else 1177 else
938 { 1178 {
939 if ( ! yy_did_buffer_switch_on_eof ) 1179 if ( ! (yy_did_buffer_switch_on_eof) )
940 YY_NEW_FILE; 1180 YY_NEW_FILE;
941 } 1181 }
942 break; 1182 break;
943 } 1183 }
944 1184
945 case EOB_ACT_CONTINUE_SCAN: 1185 case EOB_ACT_CONTINUE_SCAN:
946 yy_c_buf_p = 1186 (yy_c_buf_p) =
947 yytext_ptr + yy_amount_of_matched_text; 1187 (yytext_ptr) + yy_amount_of_matched_text;
948 1188
949 yy_current_state = yy_get_previous_state(); 1189 yy_current_state = yy_get_previous_state( );
950 1190
951 yy_cp = yy_c_buf_p; 1191 yy_cp = (yy_c_buf_p);
952 yy_bp = yytext_ptr + YY_MORE_ADJ; 1192 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
953 goto yy_match; 1193 goto yy_match;
954 1194
955 case EOB_ACT_LAST_MATCH: 1195 case EOB_ACT_LAST_MATCH:
956 yy_c_buf_p = 1196 (yy_c_buf_p) =
957 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1197 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
958 1198
959 yy_current_state = yy_get_previous_state(); 1199 yy_current_state = yy_get_previous_state( );
960 1200
961 yy_cp = yy_c_buf_p; 1201 yy_cp = (yy_c_buf_p);
962 yy_bp = yytext_ptr + YY_MORE_ADJ; 1202 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
963 goto yy_find_action; 1203 goto yy_find_action;
964 } 1204 }
965 break; 1205 break;
@@ -970,8 +1210,15 @@ case YY_STATE_EOF(V2_TOKENS):
970 "fatal flex scanner internal error--no action found" ); 1210 "fatal flex scanner internal error--no action found" );
971 } /* end of action switch */ 1211 } /* end of action switch */
972 } /* end of scanning one token */ 1212 } /* end of scanning one token */
973 } /* end of yylex */ 1213} /* end of yylex */
1214/* %ok-for-header */
974 1215
1216/* %if-c++-only */
1217/* %not-for-header */
1218
1219/* %ok-for-header */
1220
1221/* %endif */
975 1222
976/* yy_get_next_buffer - try to read in a new buffer 1223/* yy_get_next_buffer - try to read in a new buffer
977 * 1224 *
@@ -980,21 +1227,24 @@ case YY_STATE_EOF(V2_TOKENS):
980 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1227 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
981 * EOB_ACT_END_OF_FILE - end of file 1228 * EOB_ACT_END_OF_FILE - end of file
982 */ 1229 */
983 1230/* %if-c-only */
984static int yy_get_next_buffer() 1231static int yy_get_next_buffer (void)
985 { 1232/* %endif */
986 register char *dest = yy_current_buffer->yy_ch_buf; 1233/* %if-c++-only */
987 register char *source = yytext_ptr; 1234/* %endif */
1235{
1236 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1237 register char *source = (yytext_ptr);
988 register int number_to_move, i; 1238 register int number_to_move, i;
989 int ret_val; 1239 int ret_val;
990 1240
991 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1241 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
992 YY_FATAL_ERROR( 1242 YY_FATAL_ERROR(
993 "fatal flex scanner internal error--end of buffer missed" ); 1243 "fatal flex scanner internal error--end of buffer missed" );
994 1244
995 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1245 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
996 { /* Don't try to fill the buffer, so this is an EOF. */ 1246 { /* Don't try to fill the buffer, so this is an EOF. */
997 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1247 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
998 { 1248 {
999 /* We matched a single character, the EOB, so 1249 /* We matched a single character, the EOB, so
1000 * treat this as a final EOF. 1250 * treat this as a final EOF.
@@ -1014,34 +1264,30 @@ static int yy_get_next_buffer()
1014 /* Try to read more data. */ 1264 /* Try to read more data. */
1015 1265
1016 /* First move last chars to start of buffer. */ 1266 /* First move last chars to start of buffer. */
1017 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1267 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1018 1268
1019 for ( i = 0; i < number_to_move; ++i ) 1269 for ( i = 0; i < number_to_move; ++i )
1020 *(dest++) = *(source++); 1270 *(dest++) = *(source++);
1021 1271
1022 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1272 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1023 /* don't do the read, it's not guaranteed to return an EOF, 1273 /* don't do the read, it's not guaranteed to return an EOF,
1024 * just force an EOF 1274 * just force an EOF
1025 */ 1275 */
1026 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1276 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1027 1277
1028 else 1278 else
1029 { 1279 {
1030 int num_to_read = 1280 int num_to_read =
1031 yy_current_buffer->yy_buf_size - number_to_move - 1; 1281 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1032 1282
1033 while ( num_to_read <= 0 ) 1283 while ( num_to_read <= 0 )
1034 { /* Not enough room in the buffer - grow it. */ 1284 { /* Not enough room in the buffer - grow it. */
1035#ifdef YY_USES_REJECT
1036 YY_FATAL_ERROR(
1037"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1038#else
1039 1285
1040 /* just a shorter name for the current buffer */ 1286 /* just a shorter name for the current buffer */
1041 YY_BUFFER_STATE b = yy_current_buffer; 1287 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1042 1288
1043 int yy_c_buf_p_offset = 1289 int yy_c_buf_p_offset =
1044 (int) (yy_c_buf_p - b->yy_ch_buf); 1290 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1045 1291
1046 if ( b->yy_is_our_buffer ) 1292 if ( b->yy_is_our_buffer )
1047 { 1293 {
@@ -1054,8 +1300,7 @@ static int yy_get_next_buffer()
1054 1300
1055 b->yy_ch_buf = (char *) 1301 b->yy_ch_buf = (char *)
1056 /* Include room in for 2 EOB chars. */ 1302 /* Include room in for 2 EOB chars. */
1057 yy_flex_realloc( (void *) b->yy_ch_buf, 1303 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1058 b->yy_buf_size + 2 );
1059 } 1304 }
1060 else 1305 else
1061 /* Can't grow it, we don't own it. */ 1306 /* Can't grow it, we don't own it. */
@@ -1065,35 +1310,35 @@ static int yy_get_next_buffer()
1065 YY_FATAL_ERROR( 1310 YY_FATAL_ERROR(
1066 "fatal error - scanner input buffer overflow" ); 1311 "fatal error - scanner input buffer overflow" );
1067 1312
1068 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1313 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1069 1314
1070 num_to_read = yy_current_buffer->yy_buf_size - 1315 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1071 number_to_move - 1; 1316 number_to_move - 1;
1072#endif 1317
1073 } 1318 }
1074 1319
1075 if ( num_to_read > YY_READ_BUF_SIZE ) 1320 if ( num_to_read > YY_READ_BUF_SIZE )
1076 num_to_read = YY_READ_BUF_SIZE; 1321 num_to_read = YY_READ_BUF_SIZE;
1077 1322
1078 /* Read in more data. */ 1323 /* Read in more data. */
1079 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1324 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1080 yy_n_chars, num_to_read ); 1325 (yy_n_chars), (size_t) num_to_read );
1081 1326
1082 yy_current_buffer->yy_n_chars = yy_n_chars; 1327 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1083 } 1328 }
1084 1329
1085 if ( yy_n_chars == 0 ) 1330 if ( (yy_n_chars) == 0 )
1086 { 1331 {
1087 if ( number_to_move == YY_MORE_ADJ ) 1332 if ( number_to_move == YY_MORE_ADJ )
1088 { 1333 {
1089 ret_val = EOB_ACT_END_OF_FILE; 1334 ret_val = EOB_ACT_END_OF_FILE;
1090 yyrestart( yyin ); 1335 yyrestart(yyin );
1091 } 1336 }
1092 1337
1093 else 1338 else
1094 { 1339 {
1095 ret_val = EOB_ACT_LAST_MATCH; 1340 ret_val = EOB_ACT_LAST_MATCH;
1096 yy_current_buffer->yy_buffer_status = 1341 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1097 YY_BUFFER_EOF_PENDING; 1342 YY_BUFFER_EOF_PENDING;
1098 } 1343 }
1099 } 1344 }
@@ -1101,33 +1346,40 @@ static int yy_get_next_buffer()
1101 else 1346 else
1102 ret_val = EOB_ACT_CONTINUE_SCAN; 1347 ret_val = EOB_ACT_CONTINUE_SCAN;
1103 1348
1104 yy_n_chars += number_to_move; 1349 (yy_n_chars) += number_to_move;
1105 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1350 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1106 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1351 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1107 1352
1108 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1353 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1109 1354
1110 return ret_val; 1355 return ret_val;
1111 } 1356}
1112
1113 1357
1114/* yy_get_previous_state - get the state just before the EOB char was reached */ 1358/* yy_get_previous_state - get the state just before the EOB char was reached */
1115 1359
1116static yy_state_type yy_get_previous_state() 1360/* %if-c-only */
1117 { 1361/* %not-for-header */
1362
1363 static yy_state_type yy_get_previous_state (void)
1364/* %endif */
1365/* %if-c++-only */
1366/* %endif */
1367{
1118 register yy_state_type yy_current_state; 1368 register yy_state_type yy_current_state;
1119 register char *yy_cp; 1369 register char *yy_cp;
1120 1370
1121 yy_current_state = yy_start; 1371/* %% [15.0] code to get the start state into yy_current_state goes here */
1372 yy_current_state = (yy_start);
1122 yy_current_state += YY_AT_BOL(); 1373 yy_current_state += YY_AT_BOL();
1123 1374
1124 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1375 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1125 { 1376 {
1377/* %% [16.0] code to find the next state goes here */
1126 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1378 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1127 if ( yy_accept[yy_current_state] ) 1379 if ( yy_accept[yy_current_state] )
1128 { 1380 {
1129 yy_last_accepting_state = yy_current_state; 1381 (yy_last_accepting_state) = yy_current_state;
1130 yy_last_accepting_cpos = yy_cp; 1382 (yy_last_accepting_cpos) = yy_cp;
1131 } 1383 }
1132 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1384 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1133 { 1385 {
@@ -1139,30 +1391,28 @@ static yy_state_type yy_get_previous_state()
1139 } 1391 }
1140 1392
1141 return yy_current_state; 1393 return yy_current_state;
1142 } 1394}
1143
1144 1395
1145/* yy_try_NUL_trans - try to make a transition on the NUL character 1396/* yy_try_NUL_trans - try to make a transition on the NUL character
1146 * 1397 *
1147 * synopsis 1398 * synopsis
1148 * next_state = yy_try_NUL_trans( current_state ); 1399 * next_state = yy_try_NUL_trans( current_state );
1149 */ 1400 */
1150 1401/* %if-c-only */
1151#ifdef YY_USE_PROTOS 1402 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1152static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1403/* %endif */
1153#else 1404/* %if-c++-only */
1154static yy_state_type yy_try_NUL_trans( yy_current_state ) 1405/* %endif */
1155yy_state_type yy_current_state; 1406{
1156#endif
1157 {
1158 register int yy_is_jam; 1407 register int yy_is_jam;
1159 register char *yy_cp = yy_c_buf_p; 1408 /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
1409 register char *yy_cp = (yy_c_buf_p);
1160 1410
1161 register YY_CHAR yy_c = 1; 1411 register YY_CHAR yy_c = 1;
1162 if ( yy_accept[yy_current_state] ) 1412 if ( yy_accept[yy_current_state] )
1163 { 1413 {
1164 yy_last_accepting_state = yy_current_state; 1414 (yy_last_accepting_state) = yy_current_state;
1165 yy_last_accepting_cpos = yy_cp; 1415 (yy_last_accepting_cpos) = yy_cp;
1166 } 1416 }
1167 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1417 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1168 { 1418 {
@@ -1174,80 +1424,87 @@ yy_state_type yy_current_state;
1174 yy_is_jam = (yy_current_state == 75); 1424 yy_is_jam = (yy_current_state == 75);
1175 1425
1176 return yy_is_jam ? 0 : yy_current_state; 1426 return yy_is_jam ? 0 : yy_current_state;
1177 } 1427}
1178 1428
1429/* %if-c-only */
1179 1430
1180#ifndef YY_NO_UNPUT 1431 static void yyunput (int c, register char * yy_bp )
1181#ifdef YY_USE_PROTOS 1432/* %endif */
1182static void yyunput( int c, register char *yy_bp ) 1433/* %if-c++-only */
1183#else 1434/* %endif */
1184static void yyunput( c, yy_bp ) 1435{
1185int c; 1436 register char *yy_cp;
1186register char *yy_bp; 1437
1187#endif 1438 yy_cp = (yy_c_buf_p);
1188 {
1189 register char *yy_cp = yy_c_buf_p;
1190 1439
1191 /* undo effects of setting up yytext */ 1440 /* undo effects of setting up yytext */
1192 *yy_cp = yy_hold_char; 1441 *yy_cp = (yy_hold_char);
1193 1442
1194 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1443 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1195 { /* need to shift things up to make room */ 1444 { /* need to shift things up to make room */
1196 /* +2 for EOB chars. */ 1445 /* +2 for EOB chars. */
1197 register int number_to_move = yy_n_chars + 2; 1446 register int number_to_move = (yy_n_chars) + 2;
1198 register char *dest = &yy_current_buffer->yy_ch_buf[ 1447 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1199 yy_current_buffer->yy_buf_size + 2]; 1448 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1200 register char *source = 1449 register char *source =
1201 &yy_current_buffer->yy_ch_buf[number_to_move]; 1450 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1202 1451
1203 while ( source > yy_current_buffer->yy_ch_buf ) 1452 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1204 *--dest = *--source; 1453 *--dest = *--source;
1205 1454
1206 yy_cp += (int) (dest - source); 1455 yy_cp += (int) (dest - source);
1207 yy_bp += (int) (dest - source); 1456 yy_bp += (int) (dest - source);
1208 yy_current_buffer->yy_n_chars = 1457 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1209 yy_n_chars = yy_current_buffer->yy_buf_size; 1458 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1210 1459
1211 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1460 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1212 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1461 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1213 } 1462 }
1214 1463
1215 *--yy_cp = (char) c; 1464 *--yy_cp = (char) c;
1216 1465
1466/* %% [18.0] update yylineno here */
1217 1467
1218 yytext_ptr = yy_bp; 1468 (yytext_ptr) = yy_bp;
1219 yy_hold_char = *yy_cp; 1469 (yy_hold_char) = *yy_cp;
1220 yy_c_buf_p = yy_cp; 1470 (yy_c_buf_p) = yy_cp;
1221 } 1471}
1222#endif /* ifndef YY_NO_UNPUT */ 1472/* %if-c-only */
1223 1473
1474/* %endif */
1224 1475
1476/* %if-c-only */
1477#ifndef YY_NO_INPUT
1225#ifdef __cplusplus 1478#ifdef __cplusplus
1226static int yyinput() 1479 static int yyinput (void)
1227#else 1480#else
1228static int input() 1481 static int input (void)
1229#endif 1482#endif
1230 {
1231 int c;
1232 1483
1233 *yy_c_buf_p = yy_hold_char; 1484/* %endif */
1485/* %if-c++-only */
1486/* %endif */
1487{
1488 int c;
1489
1490 *(yy_c_buf_p) = (yy_hold_char);
1234 1491
1235 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1492 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1236 { 1493 {
1237 /* yy_c_buf_p now points to the character we want to return. 1494 /* yy_c_buf_p now points to the character we want to return.
1238 * If this occurs *before* the EOB characters, then it's a 1495 * If this occurs *before* the EOB characters, then it's a
1239 * valid NUL; if not, then we've hit the end of the buffer. 1496 * valid NUL; if not, then we've hit the end of the buffer.
1240 */ 1497 */
1241 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1498 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1242 /* This was really a NUL. */ 1499 /* This was really a NUL. */
1243 *yy_c_buf_p = '\0'; 1500 *(yy_c_buf_p) = '\0';
1244 1501
1245 else 1502 else
1246 { /* need more input */ 1503 { /* need more input */
1247 int offset = yy_c_buf_p - yytext_ptr; 1504 int offset = (yy_c_buf_p) - (yytext_ptr);
1248 ++yy_c_buf_p; 1505 ++(yy_c_buf_p);
1249 1506
1250 switch ( yy_get_next_buffer() ) 1507 switch ( yy_get_next_buffer( ) )
1251 { 1508 {
1252 case EOB_ACT_LAST_MATCH: 1509 case EOB_ACT_LAST_MATCH:
1253 /* This happens because yy_g_n_b() 1510 /* This happens because yy_g_n_b()
@@ -1261,16 +1518,16 @@ static int input()
1261 */ 1518 */
1262 1519
1263 /* Reset buffer status. */ 1520 /* Reset buffer status. */
1264 yyrestart( yyin ); 1521 yyrestart(yyin );
1265 1522
1266 /* fall through */ 1523 /*FALLTHROUGH*/
1267 1524
1268 case EOB_ACT_END_OF_FILE: 1525 case EOB_ACT_END_OF_FILE:
1269 { 1526 {
1270 if ( yywrap() ) 1527 if ( yywrap( ) )
1271 return EOF; 1528 return EOF;
1272 1529
1273 if ( ! yy_did_buffer_switch_on_eof ) 1530 if ( ! (yy_did_buffer_switch_on_eof) )
1274 YY_NEW_FILE; 1531 YY_NEW_FILE;
1275#ifdef __cplusplus 1532#ifdef __cplusplus
1276 return yyinput(); 1533 return yyinput();
@@ -1280,91 +1537,113 @@ static int input()
1280 } 1537 }
1281 1538
1282 case EOB_ACT_CONTINUE_SCAN: 1539 case EOB_ACT_CONTINUE_SCAN:
1283 yy_c_buf_p = yytext_ptr + offset; 1540 (yy_c_buf_p) = (yytext_ptr) + offset;
1284 break; 1541 break;
1285 } 1542 }
1286 } 1543 }
1287 } 1544 }
1288 1545
1289 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1546 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1290 *yy_c_buf_p = '\0'; /* preserve yytext */ 1547 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1291 yy_hold_char = *++yy_c_buf_p; 1548 (yy_hold_char) = *++(yy_c_buf_p);
1292 1549
1293 yy_current_buffer->yy_at_bol = (c == '\n'); 1550/* %% [19.0] update BOL and yylineno */
1551 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1294 1552
1295 return c; 1553 return c;
1554}
1555/* %if-c-only */
1556#endif /* ifndef YY_NO_INPUT */
1557/* %endif */
1558
1559/** Immediately switch to a different input stream.
1560 * @param input_file A readable stream.
1561 *
1562 * @note This function does not reset the start condition to @c INITIAL .
1563 */
1564/* %if-c-only */
1565 void yyrestart (FILE * input_file )
1566/* %endif */
1567/* %if-c++-only */
1568/* %endif */
1569{
1570
1571 if ( ! YY_CURRENT_BUFFER ){
1572 yyensure_buffer_stack ();
1573 YY_CURRENT_BUFFER_LVALUE =
1574 yy_create_buffer(yyin,YY_BUF_SIZE );
1296 } 1575 }
1297 1576
1577 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1578 yy_load_buffer_state( );
1579}
1298 1580
1299#ifdef YY_USE_PROTOS 1581/** Switch to a different input buffer.
1300void yyrestart( FILE *input_file ) 1582 * @param new_buffer The new input buffer.
1301#else 1583 *
1302void yyrestart( input_file ) 1584 */
1303FILE *input_file; 1585/* %if-c-only */
1304#endif 1586 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1305 { 1587/* %endif */
1306 if ( ! yy_current_buffer ) 1588/* %if-c++-only */
1307 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1589/* %endif */
1308 1590{
1309 yy_init_buffer( yy_current_buffer, input_file ); 1591
1310 yy_load_buffer_state(); 1592 /* TODO. We should be able to replace this entire function body
1311 } 1593 * with
1312 1594 * yypop_buffer_state();
1313 1595 * yypush_buffer_state(new_buffer);
1314#ifdef YY_USE_PROTOS 1596 */
1315void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1597 yyensure_buffer_stack ();
1316#else 1598 if ( YY_CURRENT_BUFFER == new_buffer )
1317void yy_switch_to_buffer( new_buffer )
1318YY_BUFFER_STATE new_buffer;
1319#endif
1320 {
1321 if ( yy_current_buffer == new_buffer )
1322 return; 1599 return;
1323 1600
1324 if ( yy_current_buffer ) 1601 if ( YY_CURRENT_BUFFER )
1325 { 1602 {
1326 /* Flush out information for old buffer. */ 1603 /* Flush out information for old buffer. */
1327 *yy_c_buf_p = yy_hold_char; 1604 *(yy_c_buf_p) = (yy_hold_char);
1328 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1605 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1329 yy_current_buffer->yy_n_chars = yy_n_chars; 1606 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1330 } 1607 }
1331 1608
1332 yy_current_buffer = new_buffer; 1609 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1333 yy_load_buffer_state(); 1610 yy_load_buffer_state( );
1334 1611
1335 /* We don't actually know whether we did this switch during 1612 /* We don't actually know whether we did this switch during
1336 * EOF (yywrap()) processing, but the only time this flag 1613 * EOF (yywrap()) processing, but the only time this flag
1337 * is looked at is after yywrap() is called, so it's safe 1614 * is looked at is after yywrap() is called, so it's safe
1338 * to go ahead and always set it. 1615 * to go ahead and always set it.
1339 */ 1616 */
1340 yy_did_buffer_switch_on_eof = 1; 1617 (yy_did_buffer_switch_on_eof) = 1;
1341 } 1618}
1342
1343
1344#ifdef YY_USE_PROTOS
1345void yy_load_buffer_state( void )
1346#else
1347void yy_load_buffer_state()
1348#endif
1349 {
1350 yy_n_chars = yy_current_buffer->yy_n_chars;
1351 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1352 yyin = yy_current_buffer->yy_input_file;
1353 yy_hold_char = *yy_c_buf_p;
1354 }
1355 1619
1620/* %if-c-only */
1621static void yy_load_buffer_state (void)
1622/* %endif */
1623/* %if-c++-only */
1624/* %endif */
1625{
1626 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1627 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1628 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1629 (yy_hold_char) = *(yy_c_buf_p);
1630}
1356 1631
1357#ifdef YY_USE_PROTOS 1632/** Allocate and initialize an input buffer state.
1358YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1633 * @param file A readable stream.
1359#else 1634 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1360YY_BUFFER_STATE yy_create_buffer( file, size ) 1635 *
1361FILE *file; 1636 * @return the allocated buffer state.
1362int size; 1637 */
1363#endif 1638/* %if-c-only */
1364 { 1639 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1640/* %endif */
1641/* %if-c++-only */
1642/* %endif */
1643{
1365 YY_BUFFER_STATE b; 1644 YY_BUFFER_STATE b;
1366 1645
1367 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1646 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1368 if ( ! b ) 1647 if ( ! b )
1369 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1648 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1370 1649
@@ -1373,75 +1652,99 @@ int size;
1373 /* yy_ch_buf has to be 2 characters longer than the size given because 1652 /* yy_ch_buf has to be 2 characters longer than the size given because
1374 * we need to put in 2 end-of-buffer characters. 1653 * we need to put in 2 end-of-buffer characters.
1375 */ 1654 */
1376 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1655 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1377 if ( ! b->yy_ch_buf ) 1656 if ( ! b->yy_ch_buf )
1378 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1657 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1379 1658
1380 b->yy_is_our_buffer = 1; 1659 b->yy_is_our_buffer = 1;
1381 1660
1382 yy_init_buffer( b, file ); 1661 yy_init_buffer(b,file );
1383 1662
1384 return b; 1663 return b;
1385 } 1664}
1386
1387 1665
1388#ifdef YY_USE_PROTOS 1666/** Destroy the buffer.
1389void yy_delete_buffer( YY_BUFFER_STATE b ) 1667 * @param b a buffer created with yy_create_buffer()
1390#else 1668 *
1391void yy_delete_buffer( b ) 1669 */
1392YY_BUFFER_STATE b; 1670/* %if-c-only */
1393#endif 1671 void yy_delete_buffer (YY_BUFFER_STATE b )
1394 { 1672/* %endif */
1673/* %if-c++-only */
1674/* %endif */
1675{
1676
1395 if ( ! b ) 1677 if ( ! b )
1396 return; 1678 return;
1397 1679
1398 if ( b == yy_current_buffer ) 1680 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1399 yy_current_buffer = (YY_BUFFER_STATE) 0; 1681 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1400 1682
1401 if ( b->yy_is_our_buffer ) 1683 if ( b->yy_is_our_buffer )
1402 yy_flex_free( (void *) b->yy_ch_buf ); 1684 yyfree((void *) b->yy_ch_buf );
1403 1685
1404 yy_flex_free( (void *) b ); 1686 yyfree((void *) b );
1405 } 1687}
1406 1688
1689/* %if-c-only */
1407 1690
1691#ifndef __cplusplus
1692extern int isatty (int );
1693#endif /* __cplusplus */
1694
1695/* %endif */
1408 1696
1409#ifdef YY_USE_PROTOS 1697/* %if-c++-only */
1410void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1698/* %endif */
1411#else
1412void yy_init_buffer( b, file )
1413YY_BUFFER_STATE b;
1414FILE *file;
1415#endif
1416 1699
1700/* Initializes or reinitializes a buffer.
1701 * This function is sometimes called more than once on the same buffer,
1702 * such as during a yyrestart() or at EOF.
1703 */
1704/* %if-c-only */
1705 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1706/* %endif */
1707/* %if-c++-only */
1708/* %endif */
1417 1709
1418 { 1710{
1419 yy_flush_buffer( b ); 1711 int oerrno = errno;
1712
1713 yy_flush_buffer(b );
1420 1714
1421 b->yy_input_file = file; 1715 b->yy_input_file = file;
1422 b->yy_fill_buffer = 1; 1716 b->yy_fill_buffer = 1;
1423 1717
1424#if YY_ALWAYS_INTERACTIVE 1718 /* If b is the current buffer, then yy_init_buffer was _probably_
1425 b->yy_is_interactive = 1; 1719 * called from yyrestart() or through yy_get_next_buffer.
1426#else 1720 * In that case, we don't want to reset the lineno or column.
1427#if YY_NEVER_INTERACTIVE 1721 */
1428 b->yy_is_interactive = 0; 1722 if (b != YY_CURRENT_BUFFER){
1429#else 1723 b->yy_bs_lineno = 1;
1430 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1724 b->yy_bs_column = 0;
1431#endif 1725 }
1432#endif
1433 }
1434 1726
1727/* %if-c-only */
1435 1728
1436#ifdef YY_USE_PROTOS 1729 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1437void yy_flush_buffer( YY_BUFFER_STATE b ) 1730
1438#else 1731/* %endif */
1439void yy_flush_buffer( b ) 1732/* %if-c++-only */
1440YY_BUFFER_STATE b; 1733/* %endif */
1441#endif 1734 errno = oerrno;
1735}
1442 1736
1443 { 1737/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1444 if ( ! b ) 1738 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1739 *
1740 */
1741/* %if-c-only */
1742 void yy_flush_buffer (YY_BUFFER_STATE b )
1743/* %endif */
1744/* %if-c++-only */
1745/* %endif */
1746{
1747 if ( ! b )
1445 return; 1748 return;
1446 1749
1447 b->yy_n_chars = 0; 1750 b->yy_n_chars = 0;
@@ -1458,29 +1761,140 @@ YY_BUFFER_STATE b;
1458 b->yy_at_bol = 1; 1761 b->yy_at_bol = 1;
1459 b->yy_buffer_status = YY_BUFFER_NEW; 1762 b->yy_buffer_status = YY_BUFFER_NEW;
1460 1763
1461 if ( b == yy_current_buffer ) 1764 if ( b == YY_CURRENT_BUFFER )
1462 yy_load_buffer_state(); 1765 yy_load_buffer_state( );
1766}
1767
1768/* %if-c-or-c++ */
1769/** Pushes the new state onto the stack. The new state becomes
1770 * the current state. This function will allocate the stack
1771 * if necessary.
1772 * @param new_buffer The new state.
1773 *
1774 */
1775/* %if-c-only */
1776void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1777/* %endif */
1778/* %if-c++-only */
1779/* %endif */
1780{
1781 if (new_buffer == NULL)
1782 return;
1783
1784 yyensure_buffer_stack();
1785
1786 /* This block is copied from yy_switch_to_buffer. */
1787 if ( YY_CURRENT_BUFFER )
1788 {
1789 /* Flush out information for old buffer. */
1790 *(yy_c_buf_p) = (yy_hold_char);
1791 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1792 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1793 }
1794
1795 /* Only push if top exists. Otherwise, replace top. */
1796 if (YY_CURRENT_BUFFER)
1797 (yy_buffer_stack_top)++;
1798 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1799
1800 /* copied from yy_switch_to_buffer. */
1801 yy_load_buffer_state( );
1802 (yy_did_buffer_switch_on_eof) = 1;
1803}
1804/* %endif */
1805
1806/* %if-c-or-c++ */
1807/** Removes and deletes the top of the stack, if present.
1808 * The next element becomes the new top.
1809 *
1810 */
1811/* %if-c-only */
1812void yypop_buffer_state (void)
1813/* %endif */
1814/* %if-c++-only */
1815/* %endif */
1816{
1817 if (!YY_CURRENT_BUFFER)
1818 return;
1819
1820 yy_delete_buffer(YY_CURRENT_BUFFER );
1821 YY_CURRENT_BUFFER_LVALUE = NULL;
1822 if ((yy_buffer_stack_top) > 0)
1823 --(yy_buffer_stack_top);
1824
1825 if (YY_CURRENT_BUFFER) {
1826 yy_load_buffer_state( );
1827 (yy_did_buffer_switch_on_eof) = 1;
1463 } 1828 }
1829}
1830/* %endif */
1464 1831
1832/* %if-c-or-c++ */
1833/* Allocates the stack if it does not exist.
1834 * Guarantees space for at least one push.
1835 */
1836/* %if-c-only */
1837static void yyensure_buffer_stack (void)
1838/* %endif */
1839/* %if-c++-only */
1840/* %endif */
1841{
1842 int num_to_alloc;
1843
1844 if (!(yy_buffer_stack)) {
1845
1846 /* First allocation is just for 2 elements, since we don't know if this
1847 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1848 * immediate realloc on the next call.
1849 */
1850 num_to_alloc = 1;
1851 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1852 (num_to_alloc * sizeof(struct yy_buffer_state*)
1853 );
1854
1855 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1856
1857 (yy_buffer_stack_max) = num_to_alloc;
1858 (yy_buffer_stack_top) = 0;
1859 return;
1860 }
1465 1861
1466#ifndef YY_NO_SCAN_BUFFER 1862 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1467#ifdef YY_USE_PROTOS 1863
1468YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1864 /* Increase the buffer to prepare for a possible push. */
1469#else 1865 int grow_size = 8 /* arbitrary grow size */;
1470YY_BUFFER_STATE yy_scan_buffer( base, size )
1471char *base;
1472yy_size_t size;
1473#endif
1474 {
1475 YY_BUFFER_STATE b;
1476 1866
1867 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1868 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1869 ((yy_buffer_stack),
1870 num_to_alloc * sizeof(struct yy_buffer_state*)
1871 );
1872
1873 /* zero only the new slots.*/
1874 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1875 (yy_buffer_stack_max) = num_to_alloc;
1876 }
1877}
1878/* %endif */
1879
1880/* %if-c-only */
1881/** Setup the input buffer state to scan directly from a user-specified character buffer.
1882 * @param base the character buffer
1883 * @param size the size in bytes of the character buffer
1884 *
1885 * @return the newly allocated buffer state object.
1886 */
1887YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1888{
1889 YY_BUFFER_STATE b;
1890
1477 if ( size < 2 || 1891 if ( size < 2 ||
1478 base[size-2] != YY_END_OF_BUFFER_CHAR || 1892 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1479 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1893 base[size-1] != YY_END_OF_BUFFER_CHAR )
1480 /* They forgot to leave room for the EOB's. */ 1894 /* They forgot to leave room for the EOB's. */
1481 return 0; 1895 return 0;
1482 1896
1483 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1897 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1484 if ( ! b ) 1898 if ( ! b )
1485 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1899 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1486 1900
@@ -1494,56 +1908,55 @@ yy_size_t size;
1494 b->yy_fill_buffer = 0; 1908 b->yy_fill_buffer = 0;
1495 b->yy_buffer_status = YY_BUFFER_NEW; 1909 b->yy_buffer_status = YY_BUFFER_NEW;
1496 1910
1497 yy_switch_to_buffer( b ); 1911 yy_switch_to_buffer(b );
1498 1912
1499 return b; 1913 return b;
1500 } 1914}
1501#endif 1915/* %endif */
1502 1916
1503 1917/* %if-c-only */
1504#ifndef YY_NO_SCAN_STRING 1918/** Setup the input buffer state to scan a string. The next call to yylex() will
1505#ifdef YY_USE_PROTOS 1919 * scan from a @e copy of @a str.
1506YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1920 * @param yystr a NUL-terminated string to scan
1507#else 1921 *
1508YY_BUFFER_STATE yy_scan_string( yy_str ) 1922 * @return the newly allocated buffer state object.
1509yyconst char *yy_str; 1923 * @note If you want to scan bytes that may contain NUL values, then use
1510#endif 1924 * yy_scan_bytes() instead.
1511 { 1925 */
1512 int len; 1926YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1513 for ( len = 0; yy_str[len]; ++len ) 1927{
1514 ; 1928
1515 1929 return yy_scan_bytes(yystr,strlen(yystr) );
1516 return yy_scan_bytes( yy_str, len ); 1930}
1517 } 1931/* %endif */
1518#endif 1932
1519 1933/* %if-c-only */
1520 1934/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1521#ifndef YY_NO_SCAN_BYTES 1935 * scan from a @e copy of @a bytes.
1522#ifdef YY_USE_PROTOS 1936 * @param bytes the byte buffer to scan
1523YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1937 * @param len the number of bytes in the buffer pointed to by @a bytes.
1524#else 1938 *
1525YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1939 * @return the newly allocated buffer state object.
1526yyconst char *bytes; 1940 */
1527int len; 1941YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
1528#endif 1942{
1529 {
1530 YY_BUFFER_STATE b; 1943 YY_BUFFER_STATE b;
1531 char *buf; 1944 char *buf;
1532 yy_size_t n; 1945 yy_size_t n;
1533 int i; 1946 int i;
1534 1947
1535 /* Get memory for full buffer, including space for trailing EOB's. */ 1948 /* Get memory for full buffer, including space for trailing EOB's. */
1536 n = len + 2; 1949 n = _yybytes_len + 2;
1537 buf = (char *) yy_flex_alloc( n ); 1950 buf = (char *) yyalloc(n );
1538 if ( ! buf ) 1951 if ( ! buf )
1539 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1952 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1540 1953
1541 for ( i = 0; i < len; ++i ) 1954 for ( i = 0; i < _yybytes_len; ++i )
1542 buf[i] = bytes[i]; 1955 buf[i] = yybytes[i];
1543 1956
1544 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1957 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1545 1958
1546 b = yy_scan_buffer( buf, n ); 1959 b = yy_scan_buffer(buf,n );
1547 if ( ! b ) 1960 if ( ! b )
1548 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1961 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1549 1962
@@ -1553,148 +1966,231 @@ int len;
1553 b->yy_is_our_buffer = 1; 1966 b->yy_is_our_buffer = 1;
1554 1967
1555 return b; 1968 return b;
1556 } 1969}
1970/* %endif */
1971
1972#ifndef YY_EXIT_FAILURE
1973#define YY_EXIT_FAILURE 2
1557#endif 1974#endif
1558 1975
1976/* %if-c-only */
1977static void yy_fatal_error (yyconst char* msg )
1978{
1979 (void) fprintf( stderr, "%s\n", msg );
1980 exit( YY_EXIT_FAILURE );
1981}
1982/* %endif */
1983/* %if-c++-only */
1984/* %endif */
1559 1985
1560#ifndef YY_NO_PUSH_STATE 1986/* Redefine yyless() so it works in section 3 code. */
1561#ifdef YY_USE_PROTOS
1562static void yy_push_state( int new_state )
1563#else
1564static void yy_push_state( new_state )
1565int new_state;
1566#endif
1567 {
1568 if ( yy_start_stack_ptr >= yy_start_stack_depth )
1569 {
1570 yy_size_t new_size;
1571 1987
1572 yy_start_stack_depth += YY_START_STACK_INCR; 1988#undef yyless
1573 new_size = yy_start_stack_depth * sizeof( int ); 1989#define yyless(n) \
1990 do \
1991 { \
1992 /* Undo effects of setting up yytext. */ \
1993 int yyless_macro_arg = (n); \
1994 YY_LESS_LINENO(yyless_macro_arg);\
1995 yytext[yyleng] = (yy_hold_char); \
1996 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1997 (yy_hold_char) = *(yy_c_buf_p); \
1998 *(yy_c_buf_p) = '\0'; \
1999 yyleng = yyless_macro_arg; \
2000 } \
2001 while ( 0 )
1574 2002
1575 if ( ! yy_start_stack ) 2003/* Accessor methods (get/set functions) to struct members. */
1576 yy_start_stack = (int *) yy_flex_alloc( new_size );
1577 2004
1578 else 2005/* %if-c-only */
1579 yy_start_stack = (int *) yy_flex_realloc( 2006/* %if-reentrant */
1580 (void *) yy_start_stack, new_size ); 2007/* %endif */
1581 2008
1582 if ( ! yy_start_stack ) 2009/** Get the current line number.
1583 YY_FATAL_ERROR( 2010 *
1584 "out of memory expanding start-condition stack" ); 2011 */
1585 } 2012int yyget_lineno (void)
2013{
2014
2015 return yylineno;
2016}
1586 2017
1587 yy_start_stack[yy_start_stack_ptr++] = YY_START; 2018/** Get the input stream.
2019 *
2020 */
2021FILE *yyget_in (void)
2022{
2023 return yyin;
2024}
1588 2025
1589 BEGIN(new_state); 2026/** Get the output stream.
1590 } 2027 *
1591#endif 2028 */
2029FILE *yyget_out (void)
2030{
2031 return yyout;
2032}
1592 2033
2034/** Get the length of the current token.
2035 *
2036 */
2037int yyget_leng (void)
2038{
2039 return yyleng;
2040}
1593 2041
1594#ifndef YY_NO_POP_STATE 2042/** Get the current token.
1595static void yy_pop_state() 2043 *
1596 { 2044 */
1597 if ( --yy_start_stack_ptr < 0 )
1598 YY_FATAL_ERROR( "start-condition stack underflow" );
1599 2045
1600 BEGIN(yy_start_stack[yy_start_stack_ptr]); 2046char *yyget_text (void)
1601 } 2047{
1602#endif 2048 return yytext;
2049}
1603 2050
2051/* %if-reentrant */
2052/* %endif */
1604 2053
1605#ifndef YY_NO_TOP_STATE 2054/** Set the current line number.
1606static int yy_top_state() 2055 * @param line_number
1607 { 2056 *
1608 return yy_start_stack[yy_start_stack_ptr - 1]; 2057 */
1609 } 2058void yyset_lineno (int line_number )
1610#endif 2059{
2060
2061 yylineno = line_number;
2062}
1611 2063
1612#ifndef YY_EXIT_FAILURE 2064/** Set the input stream. This does not discard the current
1613#define YY_EXIT_FAILURE 2 2065 * input buffer.
1614#endif 2066 * @param in_str A readable stream.
2067 *
2068 * @see yy_switch_to_buffer
2069 */
2070void yyset_in (FILE * in_str )
2071{
2072 yyin = in_str ;
2073}
2074
2075void yyset_out (FILE * out_str )
2076{
2077 yyout = out_str ;
2078}
2079
2080int yyget_debug (void)
2081{
2082 return yy_flex_debug;
2083}
1615 2084
1616#ifdef YY_USE_PROTOS 2085void yyset_debug (int bdebug )
1617static void yy_fatal_error( yyconst char msg[] ) 2086{
2087 yy_flex_debug = bdebug ;
2088}
2089
2090/* %endif */
2091
2092/* %if-reentrant */
2093/* %if-bison-bridge */
2094/* %endif */
2095/* %endif */
2096
2097/* %if-c-only */
2098static int yy_init_globals (void)
2099{
2100 /* Initialization is the same as for the non-reentrant scanner.
2101 * This function is called from yylex_destroy(), so don't allocate here.
2102 */
2103
2104 (yy_buffer_stack) = 0;
2105 (yy_buffer_stack_top) = 0;
2106 (yy_buffer_stack_max) = 0;
2107 (yy_c_buf_p) = (char *) 0;
2108 (yy_init) = 0;
2109 (yy_start) = 0;
2110
2111/* Defined in main.c */
2112#ifdef YY_STDINIT
2113 yyin = stdin;
2114 yyout = stdout;
1618#else 2115#else
1619static void yy_fatal_error( msg ) 2116 yyin = (FILE *) 0;
1620char msg[]; 2117 yyout = (FILE *) 0;
1621#endif 2118#endif
1622 { 2119
1623 (void) fprintf( stderr, "%s\n", msg ); 2120 /* For future reference: Set errno on error, since we are called by
1624 exit( YY_EXIT_FAILURE ); 2121 * yylex_init()
2122 */
2123 return 0;
2124}
2125/* %endif */
2126
2127/* %if-c-or-c++ */
2128/* %if-c-only */
2129/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2130int yylex_destroy (void)
2131/* %endif */
2132/* %if-c++-only */
2133/* %endif */
2134{
2135
2136 /* Pop the buffer stack, destroying each element. */
2137 while(YY_CURRENT_BUFFER){
2138 yy_delete_buffer(YY_CURRENT_BUFFER );
2139 YY_CURRENT_BUFFER_LVALUE = NULL;
2140 yypop_buffer_state();
1625 } 2141 }
1626 2142
2143 /* Destroy the stack itself. */
2144 yyfree((yy_buffer_stack) );
2145 (yy_buffer_stack) = NULL;
1627 2146
2147/* %if-c++-only */
2148/* %endif */
1628 2149
1629/* Redefine yyless() so it works in section 3 code. */ 2150/* %if-c-only */
1630 2151
1631#undef yyless 2152 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1632#define yyless(n) \ 2153 * yylex() is called, initialization will occur. */
1633 do \ 2154 yy_init_globals( );
1634 { \
1635 /* Undo effects of setting up yytext. */ \
1636 yytext[yyleng] = yy_hold_char; \
1637 yy_c_buf_p = yytext + n; \
1638 yy_hold_char = *yy_c_buf_p; \
1639 *yy_c_buf_p = '\0'; \
1640 yyleng = n; \
1641 } \
1642 while ( 0 )
1643 2155
2156/* %if-reentrant */
2157/* %endif */
2158 return 0;
2159/* %endif */
2160}
2161/* %endif */
1644 2162
1645/* Internal utility routines. */ 2163/*
2164 * Internal utility routines.
2165 */
1646 2166
1647#ifndef yytext_ptr 2167#ifndef yytext_ptr
1648#ifdef YY_USE_PROTOS 2168static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1649static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 2169{
1650#else
1651static void yy_flex_strncpy( s1, s2, n )
1652char *s1;
1653yyconst char *s2;
1654int n;
1655#endif
1656 {
1657 register int i; 2170 register int i;
1658 for ( i = 0; i < n; ++i ) 2171 for ( i = 0; i < n; ++i )
1659 s1[i] = s2[i]; 2172 s1[i] = s2[i];
1660 } 2173}
1661#endif 2174#endif
1662 2175
1663#ifdef YY_NEED_STRLEN 2176#ifdef YY_NEED_STRLEN
1664#ifdef YY_USE_PROTOS 2177static int yy_flex_strlen (yyconst char * s )
1665static int yy_flex_strlen( yyconst char *s ) 2178{
1666#else
1667static int yy_flex_strlen( s )
1668yyconst char *s;
1669#endif
1670 {
1671 register int n; 2179 register int n;
1672 for ( n = 0; s[n]; ++n ) 2180 for ( n = 0; s[n]; ++n )
1673 ; 2181 ;
1674 2182
1675 return n; 2183 return n;
1676 } 2184}
1677#endif 2185#endif
1678 2186
1679 2187void *yyalloc (yy_size_t size )
1680#ifdef YY_USE_PROTOS 2188{
1681static void *yy_flex_alloc( yy_size_t size )
1682#else
1683static void *yy_flex_alloc( size )
1684yy_size_t size;
1685#endif
1686 {
1687 return (void *) malloc( size ); 2189 return (void *) malloc( size );
1688 } 2190}
1689 2191
1690#ifdef YY_USE_PROTOS 2192void *yyrealloc (void * ptr, yy_size_t size )
1691static void *yy_flex_realloc( void *ptr, yy_size_t size ) 2193{
1692#else
1693static void *yy_flex_realloc( ptr, size )
1694void *ptr;
1695yy_size_t size;
1696#endif
1697 {
1698 /* The cast to (char *) in the following accommodates both 2194 /* The cast to (char *) in the following accommodates both
1699 * implementations that use char* generic pointers, and those 2195 * implementations that use char* generic pointers, and those
1700 * that use void* generic pointers. It works with the latter 2196 * that use void* generic pointers. It works with the latter
@@ -1703,28 +2199,24 @@ yy_size_t size;
1703 * as though doing an assignment. 2199 * as though doing an assignment.
1704 */ 2200 */
1705 return (void *) realloc( (char *) ptr, size ); 2201 return (void *) realloc( (char *) ptr, size );
1706 } 2202}
1707 2203
1708#ifdef YY_USE_PROTOS 2204void yyfree (void * ptr )
1709static void yy_flex_free( void *ptr ) 2205{
1710#else 2206 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1711static void yy_flex_free( ptr ) 2207}
1712void *ptr; 2208
1713#endif 2209/* %if-tables-serialization definitions */
1714 { 2210/* %define-yytables The name for this specific scanner's tables. */
1715 free( ptr ); 2211#define YYTABLES_NAME "yytables"
1716 } 2212/* %endif */
2213
2214/* %ok-for-header */
1717 2215
1718#if YY_MAIN
1719int main()
1720 {
1721 yylex();
1722 return 0;
1723 }
1724#endif
1725#line 95 "scripts/genksyms/lex.l" 2216#line 95 "scripts/genksyms/lex.l"
1726 2217
1727 2218
2219
1728/* Bring in the keyword recognizer. */ 2220/* Bring in the keyword recognizer. */
1729 2221
1730#include "keywords.c" 2222#include "keywords.c"
@@ -2036,10 +2528,12 @@ fini:
2036 2528
2037 return token; 2529 return token;
2038} 2530}
2039/* A Bison parser, made by GNU Bison 2.0. */ 2531/* A Bison parser, made by GNU Bison 2.3. */
2532
2533/* Skeleton interface for Bison's Yacc-like parsers in C
2040 2534
2041/* Skeleton parser for Yacc-like parsing with Bison, 2535 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
2042 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 2536 Free Software Foundation, Inc.
2043 2537
2044 This program is free software; you can redistribute it and/or modify 2538 This program is free software; you can redistribute it and/or modify
2045 it under the terms of the GNU General Public License as published by 2539 it under the terms of the GNU General Public License as published by
@@ -2053,13 +2547,21 @@ fini:
2053 2547
2054 You should have received a copy of the GNU General Public License 2548 You should have received a copy of the GNU General Public License
2055 along with this program; if not, write to the Free Software 2549 along with this program; if not, write to the Free Software
2056 Foundation, Inc., 59 Temple Place - Suite 330, 2550 Foundation, Inc., 51 Franklin Street, Fifth Floor,
2057 Boston, MA 02111-1307, USA. */ 2551 Boston, MA 02110-1301, USA. */
2058 2552
2059/* As a special exception, when this file is copied by Bison into a 2553/* As a special exception, you may create a larger work that contains
2060 Bison output file, you may use that output file without restriction. 2554 part or all of the Bison parser skeleton and distribute that work
2061 This special exception was added by the Free Software Foundation 2555 under terms of your choice, so long as that work isn't itself a
2062 in version 1.24 of Bison. */ 2556 parser generator using the skeleton or a modified version thereof
2557 as a parser skeleton. Alternatively, if you modify or redistribute
2558 the parser skeleton itself, you may (at your option) remove this
2559 special exception, which will cause the skeleton and the resulting
2560 Bison output files to be licensed under the GNU General Public
2561 License without this special exception.
2562
2563 This special exception was added by the Free Software Foundation in
2564 version 2.2 of Bison. */
2063 2565
2064/* Tokens. */ 2566/* Tokens. */
2065#ifndef YYTOKENTYPE 2567#ifndef YYTOKENTYPE
@@ -2076,39 +2578,41 @@ fini:
2076 DOUBLE_KEYW = 264, 2578 DOUBLE_KEYW = 264,
2077 ENUM_KEYW = 265, 2579 ENUM_KEYW = 265,
2078 EXTERN_KEYW = 266, 2580 EXTERN_KEYW = 266,
2079 FLOAT_KEYW = 267, 2581 EXTENSION_KEYW = 267,
2080 INLINE_KEYW = 268, 2582 FLOAT_KEYW = 268,
2081 INT_KEYW = 269, 2583 INLINE_KEYW = 269,
2082 LONG_KEYW = 270, 2584 INT_KEYW = 270,
2083 REGISTER_KEYW = 271, 2585 LONG_KEYW = 271,
2084 RESTRICT_KEYW = 272, 2586 REGISTER_KEYW = 272,
2085 SHORT_KEYW = 273, 2587 RESTRICT_KEYW = 273,
2086 SIGNED_KEYW = 274, 2588 SHORT_KEYW = 274,
2087 STATIC_KEYW = 275, 2589 SIGNED_KEYW = 275,
2088 STRUCT_KEYW = 276, 2590 STATIC_KEYW = 276,
2089 TYPEDEF_KEYW = 277, 2591 STRUCT_KEYW = 277,
2090 UNION_KEYW = 278, 2592 TYPEDEF_KEYW = 278,
2091 UNSIGNED_KEYW = 279, 2593 UNION_KEYW = 279,
2092 VOID_KEYW = 280, 2594 UNSIGNED_KEYW = 280,
2093 VOLATILE_KEYW = 281, 2595 VOID_KEYW = 281,
2094 TYPEOF_KEYW = 282, 2596 VOLATILE_KEYW = 282,
2095 EXPORT_SYMBOL_KEYW = 283, 2597 TYPEOF_KEYW = 283,
2096 ASM_PHRASE = 284, 2598 EXPORT_SYMBOL_KEYW = 284,
2097 ATTRIBUTE_PHRASE = 285, 2599 ASM_PHRASE = 285,
2098 BRACE_PHRASE = 286, 2600 ATTRIBUTE_PHRASE = 286,
2099 BRACKET_PHRASE = 287, 2601 BRACE_PHRASE = 287,
2100 EXPRESSION_PHRASE = 288, 2602 BRACKET_PHRASE = 288,
2101 CHAR = 289, 2603 EXPRESSION_PHRASE = 289,
2102 DOTS = 290, 2604 CHAR = 290,
2103 IDENT = 291, 2605 DOTS = 291,
2104 INT = 292, 2606 IDENT = 292,
2105 REAL = 293, 2607 INT = 293,
2106 STRING = 294, 2608 REAL = 294,
2107 TYPE = 295, 2609 STRING = 295,
2108 OTHER = 296, 2610 TYPE = 296,
2109 FILENAME = 297 2611 OTHER = 297,
2612 FILENAME = 298
2110 }; 2613 };
2111#endif 2614#endif
2615/* Tokens. */
2112#define ASM_KEYW 258 2616#define ASM_KEYW 258
2113#define ATTRIBUTE_KEYW 259 2617#define ATTRIBUTE_KEYW 259
2114#define AUTO_KEYW 260 2618#define AUTO_KEYW 260
@@ -2118,42 +2622,43 @@ fini:
2118#define DOUBLE_KEYW 264 2622#define DOUBLE_KEYW 264
2119#define ENUM_KEYW 265 2623#define ENUM_KEYW 265
2120#define EXTERN_KEYW 266 2624#define EXTERN_KEYW 266
2121#define FLOAT_KEYW 267 2625#define EXTENSION_KEYW 267
2122#define INLINE_KEYW 268 2626#define FLOAT_KEYW 268
2123#define INT_KEYW 269 2627#define INLINE_KEYW 269
2124#define LONG_KEYW 270 2628#define INT_KEYW 270
2125#define REGISTER_KEYW 271 2629#define LONG_KEYW 271
2126#define RESTRICT_KEYW 272 2630#define REGISTER_KEYW 272
2127#define SHORT_KEYW 273 2631#define RESTRICT_KEYW 273
2128#define SIGNED_KEYW 274 2632#define SHORT_KEYW 274
2129#define STATIC_KEYW 275 2633#define SIGNED_KEYW 275
2130#define STRUCT_KEYW 276 2634#define STATIC_KEYW 276
2131#define TYPEDEF_KEYW 277 2635#define STRUCT_KEYW 277
2132#define UNION_KEYW 278 2636#define TYPEDEF_KEYW 278
2133#define UNSIGNED_KEYW 279 2637#define UNION_KEYW 279
2134#define VOID_KEYW 280 2638#define UNSIGNED_KEYW 280
2135#define VOLATILE_KEYW 281 2639#define VOID_KEYW 281
2136#define TYPEOF_KEYW 282 2640#define VOLATILE_KEYW 282
2137#define EXPORT_SYMBOL_KEYW 283 2641#define TYPEOF_KEYW 283
2138#define ASM_PHRASE 284 2642#define EXPORT_SYMBOL_KEYW 284
2139#define ATTRIBUTE_PHRASE 285 2643#define ASM_PHRASE 285
2140#define BRACE_PHRASE 286 2644#define ATTRIBUTE_PHRASE 286
2141#define BRACKET_PHRASE 287 2645#define BRACE_PHRASE 287
2142#define EXPRESSION_PHRASE 288 2646#define BRACKET_PHRASE 288
2143#define CHAR 289 2647#define EXPRESSION_PHRASE 289
2144#define DOTS 290 2648#define CHAR 290
2145#define IDENT 291 2649#define DOTS 291
2146#define INT 292 2650#define IDENT 292
2147#define REAL 293 2651#define INT 293
2148#define STRING 294 2652#define REAL 294
2149#define TYPE 295 2653#define STRING 295
2150#define OTHER 296 2654#define TYPE 296
2151#define FILENAME 297 2655#define OTHER 297
2152 2656#define FILENAME 298
2153 2657
2154 2658
2155 2659
2156#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 2660
2661#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
2157typedef int YYSTYPE; 2662typedef int YYSTYPE;
2158# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 2663# define yystype YYSTYPE /* obsolescent; will be withdrawn */
2159# define YYSTYPE_IS_DECLARED 1 2664# define YYSTYPE_IS_DECLARED 1
@@ -2163,4 +2668,3 @@ typedef int YYSTYPE;
2163extern YYSTYPE yylval; 2668extern YYSTYPE yylval;
2164 2669
2165 2670
2166
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-28 09:00:59 -0500