/* ![[previous]](../icons/n_left.png)
![[next]](../icons/n_right.png)
![[first]](../icons/first.png)
![[last]](../icons/last.png)
![[top]](../icons/n_top.png)
![[bottom]](../icons/bottom.png)
![[index]](../icons/index.png)
![[help]](../icons/help.png)
*/
This source file includes following definitions.
- yy_get_next_buffer
- yy_get_previous_state
- yy_try_NUL_trans
- yyunput
- yyinput
- java_restart
- java__switch_to_buffer
- java__load_buffer_state
- java__create_buffer
- java__delete_buffer
- java__init_buffer
- java__flush_buffer
- java_push_buffer_state
- java_pop_buffer_state
- java_ensure_buffer_stack
- java__scan_buffer
- java__scan_string
- java__scan_bytes
- yy_push_state
- yy_pop_state
- yy_fatal_error
- java_get_lineno
- java_get_in
- java_get_out
- java_get_leng
- java_get_text
- java_set_lineno
- java_set_in
- java_set_out
- java_get_debug
- java_set_debug
- yy_init_globals
- java_lex_destroy
- yy_flex_strncpy
- yy_flex_strlen
- java_alloc
- java_realloc
- java_free
- java_parser_init
1 #line 2 "java.c"
2
3 #line 4 "java.c"
4
5 #define YY_INT_ALIGNED short int
6
7 /* A lexical scanner generated by flex */
8
9 #define yy_create_buffer java__create_buffer
10 #define yy_delete_buffer java__delete_buffer
11 #define yy_flex_debug java__flex_debug
12 #define yy_init_buffer java__init_buffer
13 #define yy_flush_buffer java__flush_buffer
14 #define yy_load_buffer_state java__load_buffer_state
15 #define yy_switch_to_buffer java__switch_to_buffer
16 #define yyin java_in
17 #define yyleng java_leng
18 #define yylex java_lex
19 #define yylineno java_lineno
20 #define yyout java_out
21 #define yyrestart java_restart
22 #define yytext java_text
23 #define yywrap java_wrap
24 #define yyalloc java_alloc
25 #define yyrealloc java_realloc
26 #define yyfree java_free
27
28 #define FLEX_SCANNER
29 #define YY_FLEX_MAJOR_VERSION 2
30 #define YY_FLEX_MINOR_VERSION 5
31 #define YY_FLEX_SUBMINOR_VERSION 35
32 #if YY_FLEX_SUBMINOR_VERSION > 0
33 #define FLEX_BETA
34 #endif
35
36 /* First, we deal with platform-specific or compiler-specific issues. */
37
38 /* begin standard C headers. */
39 #include <stdio.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <stdlib.h>
43
44 /* end standard C headers. */
45
46 /* flex integer type definitions */
47
48 #ifndef FLEXINT_H
49 #define FLEXINT_H
50
51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52
53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54
55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56 * if you want the limit (max/min) macros for int types.
57 */
58 #ifndef __STDC_LIMIT_MACROS
59 #define __STDC_LIMIT_MACROS 1
60 #endif
61
62 #include <inttypes.h>
63 typedef int8_t flex_int8_t;
64 typedef uint8_t flex_uint8_t;
65 typedef int16_t flex_int16_t;
66 typedef uint16_t flex_uint16_t;
67 typedef int32_t flex_int32_t;
68 typedef uint32_t flex_uint32_t;
69 #else
70 typedef signed char flex_int8_t;
71 typedef short int flex_int16_t;
72 typedef int flex_int32_t;
73 typedef unsigned char flex_uint8_t;
74 typedef unsigned short int flex_uint16_t;
75 typedef unsigned int flex_uint32_t;
76 #endif /* ! C99 */
77
78 /* Limits of integral types. */
79 #ifndef INT8_MIN
80 #define INT8_MIN (-128)
81 #endif
82 #ifndef INT16_MIN
83 #define INT16_MIN (-32767-1)
84 #endif
85 #ifndef INT32_MIN
86 #define INT32_MIN (-2147483647-1)
87 #endif
88 #ifndef INT8_MAX
89 #define INT8_MAX (127)
90 #endif
91 #ifndef INT16_MAX
92 #define INT16_MAX (32767)
93 #endif
94 #ifndef INT32_MAX
95 #define INT32_MAX (2147483647)
96 #endif
97 #ifndef UINT8_MAX
98 #define UINT8_MAX (255U)
99 #endif
100 #ifndef UINT16_MAX
101 #define UINT16_MAX (65535U)
102 #endif
103 #ifndef UINT32_MAX
104 #define UINT32_MAX (4294967295U)
105 #endif
106
107 #endif /* ! FLEXINT_H */
108
109 #ifdef __cplusplus
110
111 /* The "const" storage-class-modifier is valid. */
112 #define YY_USE_CONST
113
114 #else /* ! __cplusplus */
115
116 /* C99 requires __STDC__ to be defined as 1. */
117 #if defined (__STDC__)
118
119 #define YY_USE_CONST
120
121 #endif /* defined (__STDC__) */
122 #endif /* ! __cplusplus */
123
124 #ifdef YY_USE_CONST
125 #define yyconst const
126 #else
127 #define yyconst
128 #endif
129
130 /* Returned upon end-of-file. */
131 #define YY_NULL 0
132
133 /* Promotes a possibly negative, possibly signed char to an unsigned
134 * integer for use as an array index. If the signed char is negative,
135 * we want to instead treat it as an 8-bit unsigned char, hence the
136 * double cast.
137 */
138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
139
140 /* Enter a start condition. This macro really ought to take a parameter,
141 * but we do it the disgusting crufty way forced on us by the ()-less
142 * definition of BEGIN.
143 */
144 #define BEGIN (yy_start) = 1 + 2 *
145
146 /* Translate the current start state into a value that can be later handed
147 * to BEGIN to return to the state. The YYSTATE alias is for lex
148 * compatibility.
149 */
150 #define YY_START (((yy_start) - 1) / 2)
151 #define YYSTATE YY_START
152
153 /* Action number for EOF rule of a given start state. */
154 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155
156 /* Special action meaning "start processing a new file". */
157 #define YY_NEW_FILE java_restart(java_in )
158
159 #define YY_END_OF_BUFFER_CHAR 0
160
161 /* Size of default input buffer. */
162 #ifndef YY_BUF_SIZE
163 #define YY_BUF_SIZE 16384
164 #endif
165
166 /* The state buf must be large enough to hold one state per character in the main buffer.
167 */
168 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
169
170 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
171 #define YY_TYPEDEF_YY_BUFFER_STATE
172 typedef struct yy_buffer_state *YY_BUFFER_STATE;
173 #endif
174
175 extern int java_leng;
176
177 extern FILE *java_in, *java_out;
178
179 #define EOB_ACT_CONTINUE_SCAN 0
180 #define EOB_ACT_END_OF_FILE 1
181 #define EOB_ACT_LAST_MATCH 2
182
183 #define YY_LESS_LINENO(n)
184
185 /* Return all but the first "n" matched characters back to the input stream. */
186 #define yyless(n) \
187 do \
188 { \
189 /* Undo effects of setting up java_text. */ \
190 int yyless_macro_arg = (n); \
191 YY_LESS_LINENO(yyless_macro_arg);\
192 *yy_cp = (yy_hold_char); \
193 YY_RESTORE_YY_MORE_OFFSET \
194 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195 YY_DO_BEFORE_ACTION; /* set up java_text again */ \
196 } \
197 while ( 0 )
198
199 #define unput(c) yyunput( c, (yytext_ptr) )
200
201 #ifndef YY_TYPEDEF_YY_SIZE_T
202 #define YY_TYPEDEF_YY_SIZE_T
203 typedef size_t yy_size_t;
204 #endif
205
206 #ifndef YY_STRUCT_YY_BUFFER_STATE
207 #define YY_STRUCT_YY_BUFFER_STATE
208 struct yy_buffer_state
209 {
210 FILE *yy_input_file;
211
212 char *yy_ch_buf; /* input buffer */
213 char *yy_buf_pos; /* current position in input buffer */
214
215 /* Size of input buffer in bytes, not including room for EOB
216 * characters.
217 */
218 yy_size_t yy_buf_size;
219
220 /* Number of characters read into yy_ch_buf, not including EOB
221 * characters.
222 */
223 int yy_n_chars;
224
225 /* Whether we "own" the buffer - i.e., we know we created it,
226 * and can realloc() it to grow it, and should free() it to
227 * delete it.
228 */
229 int yy_is_our_buffer;
230
231 /* Whether this is an "interactive" input source; if so, and
232 * if we're using stdio for input, then we want to use getc()
233 * instead of fread(), to make sure we stop fetching input after
234 * each newline.
235 */
236 int yy_is_interactive;
237
238 /* Whether we're considered to be at the beginning of a line.
239 * If so, '^' rules will be active on the next match, otherwise
240 * not.
241 */
242 int yy_at_bol;
243
244 int yy_bs_lineno; /**< The line count. */
245 int yy_bs_column; /**< The column count. */
246
247 /* Whether to try to fill the input buffer when we reach the
248 * end of it.
249 */
250 int yy_fill_buffer;
251
252 int yy_buffer_status;
253
254 #define YY_BUFFER_NEW 0
255 #define YY_BUFFER_NORMAL 1
256 /* When an EOF's been seen but there's still some text to process
257 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
258 * shouldn't try reading from the input source any more. We might
259 * still have a bunch of tokens to match, though, because of
260 * possible backing-up.
261 *
262 * When we actually see the EOF, we change the status to "new"
263 * (via java_restart()), so that the user can continue scanning by
264 * just pointing java_in at a new input file.
265 */
266 #define YY_BUFFER_EOF_PENDING 2
267
268 };
269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
270
271 /* Stack of input buffers. */
272 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
273 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
274 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
275
276 /* We provide macros for accessing buffer states in case in the
277 * future we want to put the buffer states in a more general
278 * "scanner state".
279 *
280 * Returns the top of the stack, or NULL.
281 */
282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
284 : NULL)
285
286 /* Same as previous macro, but useful when we know that the buffer stack is not
287 * NULL or when we need an lvalue. For internal use only.
288 */
289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
290
291 /* yy_hold_char holds the character lost when java_text is formed. */
292 static char yy_hold_char;
293 static int yy_n_chars; /* number of characters read into yy_ch_buf */
294 int java_leng;
295
296 /* Points to current character in buffer. */
297 static char *yy_c_buf_p = (char *) 0;
298 static int yy_init = 0; /* whether we need to initialize */
299 static int yy_start = 0; /* start state number */
300
301 /* Flag which is used to allow java_wrap()'s to do buffer switches
302 * instead of setting up a fresh java_in. A bit of a hack ...
303 */
304 static int yy_did_buffer_switch_on_eof;
305
306 void java_restart (FILE *input_file );
307 void java__switch_to_buffer (YY_BUFFER_STATE new_buffer );
308 YY_BUFFER_STATE java__create_buffer (FILE *file,int size );
309 void java__delete_buffer (YY_BUFFER_STATE b );
310 void java__flush_buffer (YY_BUFFER_STATE b );
311 void java_push_buffer_state (YY_BUFFER_STATE new_buffer );
312 void java_pop_buffer_state (void );
313
314 static void java_ensure_buffer_stack (void );
315 static void java__load_buffer_state (void );
316 static void java__init_buffer (YY_BUFFER_STATE b,FILE *file );
317
318 #define YY_FLUSH_BUFFER java__flush_buffer(YY_CURRENT_BUFFER )
319
320 YY_BUFFER_STATE java__scan_buffer (char *base,yy_size_t size );
321 YY_BUFFER_STATE java__scan_string (yyconst char *yy_str );
322 YY_BUFFER_STATE java__scan_bytes (yyconst char *bytes,int len );
323
324 void *java_alloc (yy_size_t );
325 void *java_realloc (void *,yy_size_t );
326 void java_free (void * );
327
328 #define yy_new_buffer java__create_buffer
329
330 #define yy_set_interactive(is_interactive) \
331 { \
332 if ( ! YY_CURRENT_BUFFER ){ \
333 java_ensure_buffer_stack (); \
334 YY_CURRENT_BUFFER_LVALUE = \
335 java__create_buffer(java_in,YY_BUF_SIZE ); \
336 } \
337 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
338 }
339
340 #define yy_set_bol(at_bol) \
341 { \
342 if ( ! YY_CURRENT_BUFFER ){\
343 java_ensure_buffer_stack (); \
344 YY_CURRENT_BUFFER_LVALUE = \
345 java__create_buffer(java_in,YY_BUF_SIZE ); \
346 } \
347 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
348 }
349
350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
351
352 /* Begin user sect3 */
353
354 #define java_wrap(n) 1
355 #define YY_SKIP_YYWRAP
356
357 typedef unsigned char YY_CHAR;
358
359 FILE *java_in = (FILE *) 0, *java_out = (FILE *) 0;
360
361 typedef int yy_state_type;
362
363 extern int java_lineno;
364
365 int java_lineno = 1;
366
367 extern char *java_text;
368 #define yytext_ptr java_text
369
370 static yy_state_type yy_get_previous_state (void );
371 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
372 static int yy_get_next_buffer (void );
373 static void yy_fatal_error (yyconst char msg[] );
374
375 /* Done after the current pattern has been matched and before the
376 * corresponding action - sets up java_text.
377 */
378 #define YY_DO_BEFORE_ACTION \
379 (yytext_ptr) = yy_bp; \
380 java_leng = (size_t) (yy_cp - yy_bp); \
381 (yy_hold_char) = *yy_cp; \
382 *yy_cp = '\0'; \
383 (yy_c_buf_p) = yy_cp;
384
385 #define YY_NUM_RULES 17
386 #define YY_END_OF_BUFFER 18
387 /* This struct is not used in this scanner,
388 but its presence is necessary. */
389 struct yy_trans_info
390 {
391 flex_int32_t yy_verify;
392 flex_int32_t yy_nxt;
393 };
394 static yyconst flex_int16_t yy_accept[60] =
395 { 0,
396 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
397 0, 0, 0, 0, 0, 0, 18, 16, 15, 5,
398 8, 16, 16, 16, 12, 13, 14, 13, 3, 3,
399 6, 16, 9, 16, 0, 12, 12, 1, 4, 0,
400 12, 13, 13, 2, 7, 10, 0, 12, 13, 0,
401 12, 0, 13, 0, 12, 13, 13, 11, 0
402 } ;
403
404 static yyconst flex_int32_t yy_ec[256] =
405 { 0,
406 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 1, 2, 1, 4, 1, 1, 1, 1, 5, 1,
410 1, 6, 7, 1, 8, 9, 10, 11, 11, 11,
411 11, 11, 11, 11, 11, 11, 11, 1, 1, 1,
412 1, 1, 1, 1, 12, 12, 12, 12, 13, 12,
413 12, 12, 12, 12, 12, 14, 12, 12, 12, 12,
414 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
415 1, 15, 1, 1, 12, 1, 12, 12, 12, 12,
416
417 13, 12, 12, 12, 16, 12, 12, 12, 17, 12,
418 18, 19, 12, 20, 12, 21, 12, 12, 12, 12,
419 12, 12, 22, 1, 22, 1, 1, 12, 12, 12,
420 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
421 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
422 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
423 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
424 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
425 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
426 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
427
428 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
429 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
430 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
431 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
432 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
433 12, 12, 12, 12, 12
434 } ;
435
436 static yyconst flex_int32_t yy_meta[23] =
437 { 0,
438 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
439 3, 3, 3, 3, 1, 3, 3, 3, 3, 3,
440 3, 1
441 } ;
442
443 static yyconst flex_int16_t yy_base[65] =
444 { 0,
445 90, 89, 0, 75, 20, 21, 87, 86, 85, 84,
446 25, 27, 29, 30, 83, 82, 84, 94, 94, 94,
447 94, 27, 72, 31, 37, 0, 94, 65, 94, 71,
448 94, 0, 94, 0, 69, 38, 42, 94, 94, 68,
449 94, 0, 58, 94, 94, 94, 49, 48, 56, 54,
450 53, 55, 38, 43, 39, 22, 37, 94, 94, 66,
451 69, 22, 72, 75
452 } ;
453
454 static yyconst flex_int16_t yy_def[65] =
455 { 0,
456 60, 60, 59, 3, 61, 61, 60, 60, 60, 60,
457 60, 60, 60, 60, 60, 60, 59, 59, 59, 59,
458 59, 59, 59, 59, 59, 62, 59, 62, 59, 59,
459 59, 63, 59, 64, 59, 59, 59, 59, 59, 59,
460 59, 62, 62, 59, 59, 59, 59, 59, 62, 59,
461 59, 59, 62, 59, 59, 62, 62, 59, 0, 59,
462 59, 59, 59, 59
463 } ;
464
465 static yyconst flex_int16_t yy_nxt[117] =
466 { 0,
467 18, 18, 19, 20, 21, 18, 18, 22, 23, 24,
468 25, 26, 26, 26, 18, 26, 26, 26, 26, 26,
469 26, 27, 19, 19, 42, 30, 30, 19, 31, 19,
470 31, 19, 19, 33, 33, 35, 38, 36, 58, 32,
471 39, 32, 57, 34, 34, 40, 40, 36, 36, 55,
472 41, 41, 37, 55, 47, 50, 50, 56, 48, 51,
473 52, 54, 54, 51, 51, 55, 18, 18, 18, 29,
474 29, 29, 45, 53, 45, 46, 49, 46, 48, 37,
475 44, 43, 37, 59, 19, 19, 19, 19, 19, 19,
476 28, 19, 19, 17, 59, 59, 59, 59, 59, 59,
477
478 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
479 59, 59, 59, 59, 59, 59
480 } ;
481
482 static yyconst flex_int16_t yy_chk[117] =
483 { 0,
484 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
485 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
486 3, 3, 5, 6, 62, 5, 6, 11, 11, 12,
487 12, 13, 14, 13, 14, 22, 24, 22, 57, 11,
488 24, 12, 56, 13, 14, 25, 36, 25, 36, 55,
489 25, 36, 37, 54, 37, 47, 47, 53, 48, 47,
490 48, 52, 52, 51, 50, 52, 60, 60, 60, 61,
491 61, 61, 63, 49, 63, 64, 43, 64, 40, 35,
492 30, 28, 23, 17, 16, 15, 10, 9, 8, 7,
493 4, 2, 1, 59, 59, 59, 59, 59, 59, 59,
494
495 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
496 59, 59, 59, 59, 59, 59
497 } ;
498
499 static yy_state_type yy_last_accepting_state;
500 static char *yy_last_accepting_cpos;
501
502 extern int java__flex_debug;
503 int java__flex_debug = 0;
504
505 /* The intent behind this definition is that it'll catch
506 * any uses of REJECT which flex missed.
507 */
508 #define REJECT reject_used_but_not_detected
509 #define yymore() yymore_used_but_not_detected
510 #define YY_MORE_ADJ 0
511 #define YY_RESTORE_YY_MORE_OFFSET
512 char *java_text;
513 #line 1 "java.l"
514 #line 2 "java.l"
515 /*
516 * Copyright (c) 2002, 2004 Tama Communications Corporation
517 *
518 * This file is part of GNU GLOBAL.
519 *
520 * This program is free software: you can redistribute it and/or modify
521 * it under the terms of the GNU General Public License as published by
522 * the Free Software Foundation, either version 3 of the License, or
523 * (at your option) any later version.
524 *
525 * This program is distributed in the hope that it will be useful,
526 * but WITHOUT ANY WARRANTY; without even the implied warranty of
527 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
528 * GNU General Public License for more details.
529 *
530 * You should have received a copy of the GNU General Public License
531 * along with this program. If not, see <http://www.gnu.org/licenses/>.
532 */
533
534 /*
535 * scanner for java source code.
536 */
537 #ifdef HAVE_CONFIG_H
538 #include <config.h>
539 #endif
540 #include <stdio.h>
541 #ifdef STDC_HEADERS
542 #include <stdlib.h>
543 #endif
544 #include "global.h"
545 #include "anchor.h"
546 #include "common.h"
547 #include "htags.h"
548 #include "../libparser/java_res.h"
549
550 #define lex_symbol_generation_rule(x) java_ ## x
551 #include "lexcommon.h"
552
553 #ifdef ECHO
554 #undef ECHO
555 #endif
556 #define ECHO echos(LEXTEXT)
557
558 #define YY_USER_ACTION DEFAULT_YY_USER_ACTION
559
560 /* Definitions */
561
562 #line 563 "java.c"
563
564 #define INITIAL 0
565 #define JAVA 1
566 #define C_COMMENT 2
567 #define CPP_COMMENT 3
568 #define SHELL_COMMENT 4
569 #define STRING 5
570 #define LITERAL 6
571 #define PREPROCESSOR_LINE 7
572
573 #ifndef YY_NO_UNISTD_H
574 /* Special case for "unistd.h", since it is non-ANSI. We include it way
575 * down here because we want the user's section 1 to have been scanned first.
576 * The user has a chance to override it with an option.
577 */
578 #include <unistd.h>
579 #endif
580
581 #ifndef YY_EXTRA_TYPE
582 #define YY_EXTRA_TYPE void *
583 #endif
584
585 static int yy_init_globals (void );
586
587 /* Accessor methods to globals.
588 These are made visible to non-reentrant scanners for convenience. */
589
590 int java_lex_destroy (void );
591
592 int java_get_debug (void );
593
594 void java_set_debug (int debug_flag );
595
596 YY_EXTRA_TYPE java_get_extra (void );
597
598 void java_set_extra (YY_EXTRA_TYPE user_defined );
599
600 FILE *java_get_in (void );
601
602 void java_set_in (FILE * in_str );
603
604 FILE *java_get_out (void );
605
606 void java_set_out (FILE * out_str );
607
608 int java_get_leng (void );
609
610 char *java_get_text (void );
611
612 int java_get_lineno (void );
613
614 void java_set_lineno (int line_number );
615
616 /* Macros after this point can all be overridden by user definitions in
617 * section 1.
618 */
619
620 #ifndef YY_SKIP_YYWRAP
621 #ifdef __cplusplus
622 extern "C" int java_wrap (void );
623 #else
624 extern int java_wrap (void );
625 #endif
626 #endif
627
628 static void yyunput (int c,char *buf_ptr );
629
630 #ifndef yytext_ptr
631 static void yy_flex_strncpy (char *,yyconst char *,int );
632 #endif
633
634 #ifdef YY_NEED_STRLEN
635 static int yy_flex_strlen (yyconst char * );
636 #endif
637
638 #ifndef YY_NO_INPUT
639
640 #ifdef __cplusplus
641 static int yyinput (void );
642 #else
643 static int input (void );
644 #endif
645
646 #endif
647
648 static int yy_start_stack_ptr = 0;
649 static int yy_start_stack_depth = 0;
650 static int *yy_start_stack = NULL;
651
652 static void yy_push_state (int new_state );
653
654 static void yy_pop_state (void );
655
656 /* Amount of stuff to slurp up with each read. */
657 #ifndef YY_READ_BUF_SIZE
658 #define YY_READ_BUF_SIZE 8192
659 #endif
660
661 /* Copy whatever the last rule matched to the standard output. */
662 #ifndef ECHO
663 /* This used to be an fputs(), but since the string might contain NUL's,
664 * we now use fwrite().
665 */
666 #define ECHO fwrite( java_text, java_leng, 1, java_out )
667 #endif
668
669 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
670 * is returned in "result".
671 */
672 #ifndef YY_INPUT
673 #define YY_INPUT(buf,result,max_size) \
674 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
675 { \
676 int c = '*'; \
677 int n; \
678 for ( n = 0; n < max_size && \
679 (c = getc( java_in )) != EOF && c != '\n'; ++n ) \
680 buf[n] = (char) c; \
681 if ( c == '\n' ) \
682 buf[n++] = (char) c; \
683 if ( c == EOF && ferror( java_in ) ) \
684 YY_FATAL_ERROR( "input in flex scanner failed" ); \
685 result = n; \
686 } \
687 else \
688 { \
689 errno=0; \
690 while ( (result = fread(buf, 1, max_size, java_in))==0 && ferror(java_in)) \
691 { \
692 if( errno != EINTR) \
693 { \
694 YY_FATAL_ERROR( "input in flex scanner failed" ); \
695 break; \
696 } \
697 errno=0; \
698 clearerr(java_in); \
699 } \
700 }\
701 \
702
703 #endif
704
705 /* No semi-colon after return; correct usage is to write "yyterminate();" -
706 * we don't want an extra ';' after the "return" because that will cause
707 * some compilers to complain about unreachable statements.
708 */
709 #ifndef yyterminate
710 #define yyterminate() return YY_NULL
711 #endif
712
713 /* Number of entries by which start-condition stack grows. */
714 #ifndef YY_START_STACK_INCR
715 #define YY_START_STACK_INCR 25
716 #endif
717
718 /* Report a fatal error. */
719 #ifndef YY_FATAL_ERROR
720 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
721 #endif
722
723 /* end tables serialization structures and prototypes */
724
725 /* Default declaration of generated scanner - a define so the user can
726 * easily add parameters.
727 */
728 #ifndef YY_DECL
729 #define YY_DECL_IS_OURS 1
730
731 extern int java_lex (void);
732
733 #define YY_DECL int java_lex (void)
734 #endif /* !YY_DECL */
735
736 /* Code executed at the beginning of each rule, after java_text and java_leng
737 * have been set up.
738 */
739 #ifndef YY_USER_ACTION
740 #define YY_USER_ACTION
741 #endif
742
743 /* Code executed at the end of each rule. */
744 #ifndef YY_BREAK
745 #define YY_BREAK break;
746 #endif
747
748 #define YY_RULE_SETUP \
749 if ( java_leng > 0 ) \
750 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
751 (java_text[java_leng - 1] == '\n'); \
752 YY_USER_ACTION
753
754 /** The main scanner function which does all the work.
755 */
756 YY_DECL
757 {
758 register yy_state_type yy_current_state;
759 register char *yy_cp, *yy_bp;
760 register int yy_act;
761
762 #line 61 "java.l"
763
764 /* Comment */
765 #line 766 "java.c"
766
767 if ( !(yy_init) )
768 {
769 (yy_init) = 1;
770
771 #ifdef YY_USER_INIT
772 YY_USER_INIT;
773 #endif
774
775 if ( ! (yy_start) )
776 (yy_start) = 1; /* first start state */
777
778 if ( ! java_in )
779 java_in = stdin;
780
781 if ( ! java_out )
782 java_out = stdout;
783
784 if ( ! YY_CURRENT_BUFFER ) {
785 java_ensure_buffer_stack ();
786 YY_CURRENT_BUFFER_LVALUE =
787 java__create_buffer(java_in,YY_BUF_SIZE );
788 }
789
790 java__load_buffer_state( );
791 }
792
793 while ( 1 ) /* loops until end-of-file is reached */
794 {
795 yy_cp = (yy_c_buf_p);
796
797 /* Support of java_text. */
798 *yy_cp = (yy_hold_char);
799
800 /* yy_bp points to the position in yy_ch_buf of the start of
801 * the current run.
802 */
803 yy_bp = yy_cp;
804
805 yy_current_state = (yy_start);
806 yy_current_state += YY_AT_BOL();
807 yy_match:
808 do
809 {
810 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
811 if ( yy_accept[yy_current_state] )
812 {
813 (yy_last_accepting_state) = yy_current_state;
814 (yy_last_accepting_cpos) = yy_cp;
815 }
816 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
817 {
818 yy_current_state = (int) yy_def[yy_current_state];
819 if ( yy_current_state >= 60 )
820 yy_c = yy_meta[(unsigned int) yy_c];
821 }
822 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
823 ++yy_cp;
824 }
825 while ( yy_current_state != 59 );
826 yy_cp = (yy_last_accepting_cpos);
827 yy_current_state = (yy_last_accepting_state);
828
829 yy_find_action:
830 yy_act = yy_accept[yy_current_state];
831
832 YY_DO_BEFORE_ACTION;
833
834 do_action: /* This label is used only to access EOF actions. */
835
836 switch ( yy_act )
837 { /* beginning of action switch */
838 case 0: /* must back up */
839 /* undo the effects of YY_DO_BEFORE_ACTION */
840 *yy_cp = (yy_hold_char);
841 yy_cp = (yy_last_accepting_cpos);
842 yy_current_state = (yy_last_accepting_state);
843 goto yy_find_action;
844
845 case 1:
846 YY_RULE_SETUP
847 #line 63 "java.l"
848 { echos(comment_begin); ECHO; yy_push_state(C_COMMENT); }
849 YY_BREAK
850 case 2:
851 YY_RULE_SETUP
852 #line 64 "java.l"
853 { ECHO; echos(comment_end); yy_pop_state(); }
854 YY_BREAK
855 case 3:
856 YY_RULE_SETUP
857 #line 65 "java.l"
858 { put_char(LEXTEXT[0]); }
859 YY_BREAK
860 case 4:
861 YY_RULE_SETUP
862 #line 66 "java.l"
863 { echos(comment_begin); ECHO; yy_push_state(CPP_COMMENT); }
864 YY_BREAK
865 /* String */
866 case 5:
867 YY_RULE_SETUP
868 #line 69 "java.l"
869 { ECHO; yy_push_state(STRING); }
870 YY_BREAK
871 case 6:
872 YY_RULE_SETUP
873 #line 70 "java.l"
874 { ECHO; yy_pop_state(); }
875 YY_BREAK
876 case 7:
877 YY_RULE_SETUP
878 #line 71 "java.l"
879 { put_char(LEXTEXT[0]); put_char(LEXTEXT[1]); }
880 YY_BREAK
881 /* Literal */
882 case 8:
883 YY_RULE_SETUP
884 #line 74 "java.l"
885 { ECHO; yy_push_state(LITERAL); }
886 YY_BREAK
887 case 9:
888 YY_RULE_SETUP
889 #line 75 "java.l"
890 { ECHO; yy_pop_state(); }
891 YY_BREAK
892 case 10:
893 YY_RULE_SETUP
894 #line 76 "java.l"
895 { put_char(LEXTEXT[0]); put_char(LEXTEXT[1]); }
896 YY_BREAK
897 case 11:
898 *yy_cp = (yy_hold_char); /* undo effects of setting up java_text */
899 (yy_c_buf_p) = yy_cp = yy_bp + 6;
900 YY_DO_BEFORE_ACTION; /* set up java_text again */
901 YY_RULE_SETUP
902 #line 78 "java.l"
903 {
904 int c = 0;
905
906 put_reserved_word(LEXTEXT);
907 while ((c = input()) && c != EOF && c != '\n' && c != ';')
908 echoc(c);
909 if (c == EOF)
910 c = '\n';
911 if (c == '\n')
912 unput(c);
913 else if (c)
914 echoc(c);
915 }
916 YY_BREAK
917 case 12:
918 YY_RULE_SETUP
919 #line 92 "java.l"
920 ECHO;
921 YY_BREAK
922 case 13:
923 YY_RULE_SETUP
924 #line 93 "java.l"
925 {
926 if (java_reserved_word(LEXTEXT, LEXLENG))
927 put_reserved_word(LEXTEXT);
928 else {
929 struct anchor *a = anchor_get(LEXTEXT, LEXLENG, 0, LINENO);
930 if (a) {
931 put_anchor(gettag(a), a->type, LINENO);
932 a->done = 1;
933 } else if (grtags_is_empty) {
934 put_anchor_force(LEXTEXT, LEXLENG, LINENO);
935 } else {
936 ECHO;
937 }
938 }
939 }
940 YY_BREAK
941 case 14:
942 YY_RULE_SETUP
943 #line 108 "java.l"
944 { put_brace(LEXTEXT); }
945 YY_BREAK
946 /* New line */
947 case 15:
948 /* rule 15 can match eol */
949 YY_RULE_SETUP
950 #line 110 "java.l"
951 DEFAULT_END_OF_LINE_ACTION
952 YY_BREAK
953 case 16:
954 YY_RULE_SETUP
955 #line 111 "java.l"
956 { put_char(LEXTEXT[0]); }
957 YY_BREAK
958 case 17:
959 YY_RULE_SETUP
960 #line 113 "java.l"
961 ECHO;
962 YY_BREAK
963 #line 964 "java.c"
964 case YY_STATE_EOF(INITIAL):
965 case YY_STATE_EOF(JAVA):
966 case YY_STATE_EOF(C_COMMENT):
967 case YY_STATE_EOF(CPP_COMMENT):
968 case YY_STATE_EOF(SHELL_COMMENT):
969 case YY_STATE_EOF(STRING):
970 case YY_STATE_EOF(LITERAL):
971 case YY_STATE_EOF(PREPROCESSOR_LINE):
972 yyterminate();
973
974 case YY_END_OF_BUFFER:
975 {
976 /* Amount of text matched not including the EOB char. */
977 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
978
979 /* Undo the effects of YY_DO_BEFORE_ACTION. */
980 *yy_cp = (yy_hold_char);
981 YY_RESTORE_YY_MORE_OFFSET
982
983 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
984 {
985 /* We're scanning a new file or input source. It's
986 * possible that this happened because the user
987 * just pointed java_in at a new source and called
988 * java_lex(). If so, then we have to assure
989 * consistency between YY_CURRENT_BUFFER and our
990 * globals. Here is the right place to do so, because
991 * this is the first action (other than possibly a
992 * back-up) that will match for the new input source.
993 */
994 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
995 YY_CURRENT_BUFFER_LVALUE->yy_input_file = java_in;
996 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
997 }
998
999 /* Note that here we test for yy_c_buf_p "<=" to the position
1000 * of the first EOB in the buffer, since yy_c_buf_p will
1001 * already have been incremented past the NUL character
1002 * (since all states make transitions on EOB to the
1003 * end-of-buffer state). Contrast this with the test
1004 * in input().
1005 */
1006 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1007 { /* This was really a NUL. */
1008 yy_state_type yy_next_state;
1009
1010 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1011
1012 yy_current_state = yy_get_previous_state( );
1013
1014 /* Okay, we're now positioned to make the NUL
1015 * transition. We couldn't have
1016 * yy_get_previous_state() go ahead and do it
1017 * for us because it doesn't know how to deal
1018 * with the possibility of jamming (and we don't
1019 * want to build jamming into it because then it
1020 * will run more slowly).
1021 */
1022
1023 yy_next_state = yy_try_NUL_trans( yy_current_state );
1024
1025 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1026
1027 if ( yy_next_state )
1028 {
1029 /* Consume the NUL. */
1030 yy_cp = ++(yy_c_buf_p);
1031 yy_current_state = yy_next_state;
1032 goto yy_match;
1033 }
1034
1035 else
1036 {
1037 yy_cp = (yy_last_accepting_cpos);
1038 yy_current_state = (yy_last_accepting_state);
1039 goto yy_find_action;
1040 }
1041 }
1042
1043 else switch ( yy_get_next_buffer( ) )
1044 {
1045 case EOB_ACT_END_OF_FILE:
1046 {
1047 (yy_did_buffer_switch_on_eof) = 0;
1048
1049 if ( java_wrap( ) )
1050 {
1051 /* Note: because we've taken care in
1052 * yy_get_next_buffer() to have set up
1053 * java_text, we can now set up
1054 * yy_c_buf_p so that if some total
1055 * hoser (like flex itself) wants to
1056 * call the scanner after we return the
1057 * YY_NULL, it'll still work - another
1058 * YY_NULL will get returned.
1059 */
1060 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1061
1062 yy_act = YY_STATE_EOF(YY_START);
1063 goto do_action;
1064 }
1065
1066 else
1067 {
1068 if ( ! (yy_did_buffer_switch_on_eof) )
1069 YY_NEW_FILE;
1070 }
1071 break;
1072 }
1073
1074 case EOB_ACT_CONTINUE_SCAN:
1075 (yy_c_buf_p) =
1076 (yytext_ptr) + yy_amount_of_matched_text;
1077
1078 yy_current_state = yy_get_previous_state( );
1079
1080 yy_cp = (yy_c_buf_p);
1081 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1082 goto yy_match;
1083
1084 case EOB_ACT_LAST_MATCH:
1085 (yy_c_buf_p) =
1086 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1087
1088 yy_current_state = yy_get_previous_state( );
1089
1090 yy_cp = (yy_c_buf_p);
1091 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1092 goto yy_find_action;
1093 }
1094 break;
1095 }
1096
1097 default:
1098 YY_FATAL_ERROR(
1099 "fatal flex scanner internal error--no action found" );
1100 } /* end of action switch */
1101 } /* end of scanning one token */
1102 } /* end of java_lex */
1103
1104 /* yy_get_next_buffer - try to read in a new buffer
1105 *
1106 * Returns a code representing an action:
1107 * EOB_ACT_LAST_MATCH -
1108 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1109 * EOB_ACT_END_OF_FILE - end of file
1110 */
1111 static int yy_get_next_buffer (void)
1112 {
1113 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1114 register char *source = (yytext_ptr);
1115 register int number_to_move, i;
1116 int ret_val;
1117
1118 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1119 YY_FATAL_ERROR(
1120 "fatal flex scanner internal error--end of buffer missed" );
1121
1122 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1123 { /* Don't try to fill the buffer, so this is an EOF. */
1124 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1125 {
1126 /* We matched a single character, the EOB, so
1127 * treat this as a final EOF.
1128 */
1129 return EOB_ACT_END_OF_FILE;
1130 }
1131
1132 else
1133 {
1134 /* We matched some text prior to the EOB, first
1135 * process it.
1136 */
1137 return EOB_ACT_LAST_MATCH;
1138 }
1139 }
1140
1141 /* Try to read more data. */
1142
1143 /* First move last chars to start of buffer. */
1144 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1145
1146 for ( i = 0; i < number_to_move; ++i )
1147 *(dest++) = *(source++);
1148
1149 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1150 /* don't do the read, it's not guaranteed to return an EOF,
1151 * just force an EOF
1152 */
1153 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1154
1155 else
1156 {
1157 int num_to_read =
1158 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1159
1160 while ( num_to_read <= 0 )
1161 { /* Not enough room in the buffer - grow it. */
1162
1163 /* just a shorter name for the current buffer */
1164 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1165
1166 int yy_c_buf_p_offset =
1167 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1168
1169 if ( b->yy_is_our_buffer )
1170 {
1171 int new_size = b->yy_buf_size * 2;
1172
1173 if ( new_size <= 0 )
1174 b->yy_buf_size += b->yy_buf_size / 8;
1175 else
1176 b->yy_buf_size *= 2;
1177
1178 b->yy_ch_buf = (char *)
1179 /* Include room in for 2 EOB chars. */
1180 java_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1181 }
1182 else
1183 /* Can't grow it, we don't own it. */
1184 b->yy_ch_buf = 0;
1185
1186 if ( ! b->yy_ch_buf )
1187 YY_FATAL_ERROR(
1188 "fatal error - scanner input buffer overflow" );
1189
1190 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1191
1192 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1193 number_to_move - 1;
1194
1195 }
1196
1197 if ( num_to_read > YY_READ_BUF_SIZE )
1198 num_to_read = YY_READ_BUF_SIZE;
1199
1200 /* Read in more data. */
1201 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1202 (yy_n_chars), (size_t) num_to_read );
1203
1204 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1205 }
1206
1207 if ( (yy_n_chars) == 0 )
1208 {
1209 if ( number_to_move == YY_MORE_ADJ )
1210 {
1211 ret_val = EOB_ACT_END_OF_FILE;
1212 java_restart(java_in );
1213 }
1214
1215 else
1216 {
1217 ret_val = EOB_ACT_LAST_MATCH;
1218 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1219 YY_BUFFER_EOF_PENDING;
1220 }
1221 }
1222
1223 else
1224 ret_val = EOB_ACT_CONTINUE_SCAN;
1225
1226 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1227 /* Extend the array by 50%, plus the number we really need. */
1228 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1229 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) java_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1230 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1231 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1232 }
1233
1234 (yy_n_chars) += number_to_move;
1235 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1236 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1237
1238 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1239
1240 return ret_val;
1241 }
1242
1243 /* yy_get_previous_state - get the state just before the EOB char was reached */
1244
1245 static yy_state_type yy_get_previous_state (void)
1246 {
1247 register yy_state_type yy_current_state;
1248 register char *yy_cp;
1249
1250 yy_current_state = (yy_start);
1251 yy_current_state += YY_AT_BOL();
1252
1253 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1254 {
1255 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1256 if ( yy_accept[yy_current_state] )
1257 {
1258 (yy_last_accepting_state) = yy_current_state;
1259 (yy_last_accepting_cpos) = yy_cp;
1260 }
1261 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1262 {
1263 yy_current_state = (int) yy_def[yy_current_state];
1264 if ( yy_current_state >= 60 )
1265 yy_c = yy_meta[(unsigned int) yy_c];
1266 }
1267 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1268 }
1269
1270 return yy_current_state;
1271 }
1272
1273 /* yy_try_NUL_trans - try to make a transition on the NUL character
1274 *
1275 * synopsis
1276 * next_state = yy_try_NUL_trans( current_state );
1277 */
1278 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1279 {
1280 register int yy_is_jam;
1281 register char *yy_cp = (yy_c_buf_p);
1282
1283 register YY_CHAR yy_c = 1;
1284 if ( yy_accept[yy_current_state] )
1285 {
1286 (yy_last_accepting_state) = yy_current_state;
1287 (yy_last_accepting_cpos) = yy_cp;
1288 }
1289 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1290 {
1291 yy_current_state = (int) yy_def[yy_current_state];
1292 if ( yy_current_state >= 60 )
1293 yy_c = yy_meta[(unsigned int) yy_c];
1294 }
1295 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1296 yy_is_jam = (yy_current_state == 59);
1297
1298 return yy_is_jam ? 0 : yy_current_state;
1299 }
1300
1301 static void yyunput (int c, register char * yy_bp )
1302 {
1303 register char *yy_cp;
1304
1305 yy_cp = (yy_c_buf_p);
1306
1307 /* undo effects of setting up java_text */
1308 *yy_cp = (yy_hold_char);
1309
1310 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1311 { /* need to shift things up to make room */
1312 /* +2 for EOB chars. */
1313 register int number_to_move = (yy_n_chars) + 2;
1314 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1315 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1316 register char *source =
1317 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1318
1319 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1320 *--dest = *--source;
1321
1322 yy_cp += (int) (dest - source);
1323 yy_bp += (int) (dest - source);
1324 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1325 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1326
1327 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1328 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1329 }
1330
1331 *--yy_cp = (char) c;
1332
1333 (yytext_ptr) = yy_bp;
1334 (yy_hold_char) = *yy_cp;
1335 (yy_c_buf_p) = yy_cp;
1336 }
1337
1338 #ifndef YY_NO_INPUT
1339 #ifdef __cplusplus
1340 static int yyinput (void)
1341 #else
1342 static int input (void)
1343 #endif
1344
1345 {
1346 int c;
1347
1348 *(yy_c_buf_p) = (yy_hold_char);
1349
1350 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1351 {
1352 /* yy_c_buf_p now points to the character we want to return.
1353 * If this occurs *before* the EOB characters, then it's a
1354 * valid NUL; if not, then we've hit the end of the buffer.
1355 */
1356 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1357 /* This was really a NUL. */
1358 *(yy_c_buf_p) = '\0';
1359
1360 else
1361 { /* need more input */
1362 int offset = (yy_c_buf_p) - (yytext_ptr);
1363 ++(yy_c_buf_p);
1364
1365 switch ( yy_get_next_buffer( ) )
1366 {
1367 case EOB_ACT_LAST_MATCH:
1368 /* This happens because yy_g_n_b()
1369 * sees that we've accumulated a
1370 * token and flags that we need to
1371 * try matching the token before
1372 * proceeding. But for input(),
1373 * there's no matching to consider.
1374 * So convert the EOB_ACT_LAST_MATCH
1375 * to EOB_ACT_END_OF_FILE.
1376 */
1377
1378 /* Reset buffer status. */
1379 java_restart(java_in );
1380
1381 /*FALLTHROUGH*/
1382
1383 case EOB_ACT_END_OF_FILE:
1384 {
1385 if ( java_wrap( ) )
1386 return EOF;
1387
1388 if ( ! (yy_did_buffer_switch_on_eof) )
1389 YY_NEW_FILE;
1390 #ifdef __cplusplus
1391 return yyinput();
1392 #else
1393 return input();
1394 #endif
1395 }
1396
1397 case EOB_ACT_CONTINUE_SCAN:
1398 (yy_c_buf_p) = (yytext_ptr) + offset;
1399 break;
1400 }
1401 }
1402 }
1403
1404 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1405 *(yy_c_buf_p) = '\0'; /* preserve java_text */
1406 (yy_hold_char) = *++(yy_c_buf_p);
1407
1408 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1409
1410 return c;
1411 }
1412 #endif /* ifndef YY_NO_INPUT */
1413
1414 /** Immediately switch to a different input stream.
1415 * @param input_file A readable stream.
1416 *
1417 * @note This function does not reset the start condition to @c INITIAL .
1418 */
1419 void java_restart (FILE * input_file )
1420 {
1421
1422 if ( ! YY_CURRENT_BUFFER ){
1423 java_ensure_buffer_stack ();
1424 YY_CURRENT_BUFFER_LVALUE =
1425 java__create_buffer(java_in,YY_BUF_SIZE );
1426 }
1427
1428 java__init_buffer(YY_CURRENT_BUFFER,input_file );
1429 java__load_buffer_state( );
1430 }
1431
1432 /** Switch to a different input buffer.
1433 * @param new_buffer The new input buffer.
1434 *
1435 */
1436 void java__switch_to_buffer (YY_BUFFER_STATE new_buffer )
1437 {
1438
1439 /* TODO. We should be able to replace this entire function body
1440 * with
1441 * java_pop_buffer_state();
1442 * java_push_buffer_state(new_buffer);
1443 */
1444 java_ensure_buffer_stack ();
1445 if ( YY_CURRENT_BUFFER == new_buffer )
1446 return;
1447
1448 if ( YY_CURRENT_BUFFER )
1449 {
1450 /* Flush out information for old buffer. */
1451 *(yy_c_buf_p) = (yy_hold_char);
1452 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1453 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1454 }
1455
1456 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1457 java__load_buffer_state( );
1458
1459 /* We don't actually know whether we did this switch during
1460 * EOF (java_wrap()) processing, but the only time this flag
1461 * is looked at is after java_wrap() is called, so it's safe
1462 * to go ahead and always set it.
1463 */
1464 (yy_did_buffer_switch_on_eof) = 1;
1465 }
1466
1467 static void java__load_buffer_state (void)
1468 {
1469 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1470 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1471 java_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1472 (yy_hold_char) = *(yy_c_buf_p);
1473 }
1474
1475 /** Allocate and initialize an input buffer state.
1476 * @param file A readable stream.
1477 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1478 *
1479 * @return the allocated buffer state.
1480 */
1481 YY_BUFFER_STATE java__create_buffer (FILE * file, int size )
1482 {
1483 YY_BUFFER_STATE b;
1484
1485 b = (YY_BUFFER_STATE) java_alloc(sizeof( struct yy_buffer_state ) );
1486 if ( ! b )
1487 YY_FATAL_ERROR( "out of dynamic memory in java__create_buffer()" );
1488
1489 b->yy_buf_size = size;
1490
1491 /* yy_ch_buf has to be 2 characters longer than the size given because
1492 * we need to put in 2 end-of-buffer characters.
1493 */
1494 b->yy_ch_buf = (char *) java_alloc(b->yy_buf_size + 2 );
1495 if ( ! b->yy_ch_buf )
1496 YY_FATAL_ERROR( "out of dynamic memory in java__create_buffer()" );
1497
1498 b->yy_is_our_buffer = 1;
1499
1500 java__init_buffer(b,file );
1501
1502 return b;
1503 }
1504
1505 /** Destroy the buffer.
1506 * @param b a buffer created with java__create_buffer()
1507 *
1508 */
1509 void java__delete_buffer (YY_BUFFER_STATE b )
1510 {
1511
1512 if ( ! b )
1513 return;
1514
1515 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1516 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1517
1518 if ( b->yy_is_our_buffer )
1519 java_free((void *) b->yy_ch_buf );
1520
1521 java_free((void *) b );
1522 }
1523
1524 /* Initializes or reinitializes a buffer.
1525 * This function is sometimes called more than once on the same buffer,
1526 * such as during a java_restart() or at EOF.
1527 */
1528 static void java__init_buffer (YY_BUFFER_STATE b, FILE * file )
1529
1530 {
1531 int oerrno = errno;
1532
1533 java__flush_buffer(b );
1534
1535 b->yy_input_file = file;
1536 b->yy_fill_buffer = 1;
1537
1538 /* If b is the current buffer, then java__init_buffer was _probably_
1539 * called from java_restart() or through yy_get_next_buffer.
1540 * In that case, we don't want to reset the lineno or column.
1541 */
1542 if (b != YY_CURRENT_BUFFER){
1543 b->yy_bs_lineno = 1;
1544 b->yy_bs_column = 0;
1545 }
1546
1547 b->yy_is_interactive = 0;
1548
1549 errno = oerrno;
1550 }
1551
1552 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1553 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1554 *
1555 */
1556 void java__flush_buffer (YY_BUFFER_STATE b )
1557 {
1558 if ( ! b )
1559 return;
1560
1561 b->yy_n_chars = 0;
1562
1563 /* We always need two end-of-buffer characters. The first causes
1564 * a transition to the end-of-buffer state. The second causes
1565 * a jam in that state.
1566 */
1567 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1568 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1569
1570 b->yy_buf_pos = &b->yy_ch_buf[0];
1571
1572 b->yy_at_bol = 1;
1573 b->yy_buffer_status = YY_BUFFER_NEW;
1574
1575 if ( b == YY_CURRENT_BUFFER )
1576 java__load_buffer_state( );
1577 }
1578
1579 /** Pushes the new state onto the stack. The new state becomes
1580 * the current state. This function will allocate the stack
1581 * if necessary.
1582 * @param new_buffer The new state.
1583 *
1584 */
1585 void java_push_buffer_state (YY_BUFFER_STATE new_buffer )
1586 {
1587 if (new_buffer == NULL)
1588 return;
1589
1590 java_ensure_buffer_stack();
1591
1592 /* This block is copied from java__switch_to_buffer. */
1593 if ( YY_CURRENT_BUFFER )
1594 {
1595 /* Flush out information for old buffer. */
1596 *(yy_c_buf_p) = (yy_hold_char);
1597 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1598 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1599 }
1600
1601 /* Only push if top exists. Otherwise, replace top. */
1602 if (YY_CURRENT_BUFFER)
1603 (yy_buffer_stack_top)++;
1604 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1605
1606 /* copied from java__switch_to_buffer. */
1607 java__load_buffer_state( );
1608 (yy_did_buffer_switch_on_eof) = 1;
1609 }
1610
1611 /** Removes and deletes the top of the stack, if present.
1612 * The next element becomes the new top.
1613 *
1614 */
1615 void java_pop_buffer_state (void)
1616 {
1617 if (!YY_CURRENT_BUFFER)
1618 return;
1619
1620 java__delete_buffer(YY_CURRENT_BUFFER );
1621 YY_CURRENT_BUFFER_LVALUE = NULL;
1622 if ((yy_buffer_stack_top) > 0)
1623 --(yy_buffer_stack_top);
1624
1625 if (YY_CURRENT_BUFFER) {
1626 java__load_buffer_state( );
1627 (yy_did_buffer_switch_on_eof) = 1;
1628 }
1629 }
1630
1631 /* Allocates the stack if it does not exist.
1632 * Guarantees space for at least one push.
1633 */
1634 static void java_ensure_buffer_stack (void)
1635 {
1636 int num_to_alloc;
1637
1638 if (!(yy_buffer_stack)) {
1639
1640 /* First allocation is just for 2 elements, since we don't know if this
1641 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1642 * immediate realloc on the next call.
1643 */
1644 num_to_alloc = 1;
1645 (yy_buffer_stack) = (struct yy_buffer_state**)java_alloc
1646 (num_to_alloc * sizeof(struct yy_buffer_state*)
1647 );
1648 if ( ! (yy_buffer_stack) )
1649 YY_FATAL_ERROR( "out of dynamic memory in java_ensure_buffer_stack()" );
1650
1651 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1652
1653 (yy_buffer_stack_max) = num_to_alloc;
1654 (yy_buffer_stack_top) = 0;
1655 return;
1656 }
1657
1658 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1659
1660 /* Increase the buffer to prepare for a possible push. */
1661 int grow_size = 8 /* arbitrary grow size */;
1662
1663 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1664 (yy_buffer_stack) = (struct yy_buffer_state**)java_realloc
1665 ((yy_buffer_stack),
1666 num_to_alloc * sizeof(struct yy_buffer_state*)
1667 );
1668 if ( ! (yy_buffer_stack) )
1669 YY_FATAL_ERROR( "out of dynamic memory in java_ensure_buffer_stack()" );
1670
1671 /* zero only the new slots.*/
1672 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1673 (yy_buffer_stack_max) = num_to_alloc;
1674 }
1675 }
1676
1677 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1678 * @param base the character buffer
1679 * @param size the size in bytes of the character buffer
1680 *
1681 * @return the newly allocated buffer state object.
1682 */
1683 YY_BUFFER_STATE java__scan_buffer (char * base, yy_size_t size )
1684 {
1685 YY_BUFFER_STATE b;
1686
1687 if ( size < 2 ||
1688 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1689 base[size-1] != YY_END_OF_BUFFER_CHAR )
1690 /* They forgot to leave room for the EOB's. */
1691 return 0;
1692
1693 b = (YY_BUFFER_STATE) java_alloc(sizeof( struct yy_buffer_state ) );
1694 if ( ! b )
1695 YY_FATAL_ERROR( "out of dynamic memory in java__scan_buffer()" );
1696
1697 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1698 b->yy_buf_pos = b->yy_ch_buf = base;
1699 b->yy_is_our_buffer = 0;
1700 b->yy_input_file = 0;
1701 b->yy_n_chars = b->yy_buf_size;
1702 b->yy_is_interactive = 0;
1703 b->yy_at_bol = 1;
1704 b->yy_fill_buffer = 0;
1705 b->yy_buffer_status = YY_BUFFER_NEW;
1706
1707 java__switch_to_buffer(b );
1708
1709 return b;
1710 }
1711
1712 /** Setup the input buffer state to scan a string. The next call to java_lex() will
1713 * scan from a @e copy of @a str.
1714 * @param yystr a NUL-terminated string to scan
1715 *
1716 * @return the newly allocated buffer state object.
1717 * @note If you want to scan bytes that may contain NUL values, then use
1718 * java__scan_bytes() instead.
1719 */
1720 YY_BUFFER_STATE java__scan_string (yyconst char * yystr )
1721 {
1722
1723 return java__scan_bytes(yystr,strlen(yystr) );
1724 }
1725
1726 /** Setup the input buffer state to scan the given bytes. The next call to java_lex() will
1727 * scan from a @e copy of @a bytes.
1728 * @param bytes the byte buffer to scan
1729 * @param len the number of bytes in the buffer pointed to by @a bytes.
1730 *
1731 * @return the newly allocated buffer state object.
1732 */
1733 YY_BUFFER_STATE java__scan_bytes (yyconst char * yybytes, int _yybytes_len )
1734 {
1735 YY_BUFFER_STATE b;
1736 char *buf;
1737 yy_size_t n;
1738 int i;
1739
1740 /* Get memory for full buffer, including space for trailing EOB's. */
1741 n = _yybytes_len + 2;
1742 buf = (char *) java_alloc(n );
1743 if ( ! buf )
1744 YY_FATAL_ERROR( "out of dynamic memory in java__scan_bytes()" );
1745
1746 for ( i = 0; i < _yybytes_len; ++i )
1747 buf[i] = yybytes[i];
1748
1749 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1750
1751 b = java__scan_buffer(buf,n );
1752 if ( ! b )
1753 YY_FATAL_ERROR( "bad buffer in java__scan_bytes()" );
1754
1755 /* It's okay to grow etc. this buffer, and we should throw it
1756 * away when we're done.
1757 */
1758 b->yy_is_our_buffer = 1;
1759
1760 return b;
1761 }
1762
1763 static void yy_push_state (int new_state )
1764 {
1765 if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
1766 {
1767 yy_size_t new_size;
1768
1769 (yy_start_stack_depth) += YY_START_STACK_INCR;
1770 new_size = (yy_start_stack_depth) * sizeof( int );
1771
1772 if ( ! (yy_start_stack) )
1773 (yy_start_stack) = (int *) java_alloc(new_size );
1774
1775 else
1776 (yy_start_stack) = (int *) java_realloc((void *) (yy_start_stack),new_size );
1777
1778 if ( ! (yy_start_stack) )
1779 YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
1780 }
1781
1782 (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
1783
1784 BEGIN(new_state);
1785 }
1786
1787 static void yy_pop_state (void)
1788 {
1789 if ( --(yy_start_stack_ptr) < 0 )
1790 YY_FATAL_ERROR( "start-condition stack underflow" );
1791
1792 BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
1793 }
1794
1795 #ifndef YY_EXIT_FAILURE
1796 #define YY_EXIT_FAILURE 2
1797 #endif
1798
1799 static void yy_fatal_error (yyconst char* msg )
1800 {
1801 (void) fprintf( stderr, "%s\n", msg );
1802 exit( YY_EXIT_FAILURE );
1803 }
1804
1805 /* Redefine yyless() so it works in section 3 code. */
1806
1807 #undef yyless
1808 #define yyless(n) \
1809 do \
1810 { \
1811 /* Undo effects of setting up java_text. */ \
1812 int yyless_macro_arg = (n); \
1813 YY_LESS_LINENO(yyless_macro_arg);\
1814 java_text[java_leng] = (yy_hold_char); \
1815 (yy_c_buf_p) = java_text + yyless_macro_arg; \
1816 (yy_hold_char) = *(yy_c_buf_p); \
1817 *(yy_c_buf_p) = '\0'; \
1818 java_leng = yyless_macro_arg; \
1819 } \
1820 while ( 0 )
1821
1822 /* Accessor methods (get/set functions) to struct members. */
1823
1824 /** Get the current line number.
1825 *
1826 */
1827 int java_get_lineno (void)
1828 {
1829
1830 return java_lineno;
1831 }
1832
1833 /** Get the input stream.
1834 *
1835 */
1836 FILE *java_get_in (void)
1837 {
1838 return java_in;
1839 }
1840
1841 /** Get the output stream.
1842 *
1843 */
1844 FILE *java_get_out (void)
1845 {
1846 return java_out;
1847 }
1848
1849 /** Get the length of the current token.
1850 *
1851 */
1852 int java_get_leng (void)
1853 {
1854 return java_leng;
1855 }
1856
1857 /** Get the current token.
1858 *
1859 */
1860
1861 char *java_get_text (void)
1862 {
1863 return java_text;
1864 }
1865
1866 /** Set the current line number.
1867 * @param line_number
1868 *
1869 */
1870 void java_set_lineno (int line_number )
1871 {
1872
1873 java_lineno = line_number;
1874 }
1875
1876 /** Set the input stream. This does not discard the current
1877 * input buffer.
1878 * @param in_str A readable stream.
1879 *
1880 * @see java__switch_to_buffer
1881 */
1882 void java_set_in (FILE * in_str )
1883 {
1884 java_in = in_str ;
1885 }
1886
1887 void java_set_out (FILE * out_str )
1888 {
1889 java_out = out_str ;
1890 }
1891
1892 int java_get_debug (void)
1893 {
1894 return java__flex_debug;
1895 }
1896
1897 void java_set_debug (int bdebug )
1898 {
1899 java__flex_debug = bdebug ;
1900 }
1901
1902 static int yy_init_globals (void)
1903 {
1904 /* Initialization is the same as for the non-reentrant scanner.
1905 * This function is called from java_lex_destroy(), so don't allocate here.
1906 */
1907
1908 (yy_buffer_stack) = 0;
1909 (yy_buffer_stack_top) = 0;
1910 (yy_buffer_stack_max) = 0;
1911 (yy_c_buf_p) = (char *) 0;
1912 (yy_init) = 0;
1913 (yy_start) = 0;
1914
1915 (yy_start_stack_ptr) = 0;
1916 (yy_start_stack_depth) = 0;
1917 (yy_start_stack) = NULL;
1918
1919 /* Defined in main.c */
1920 #ifdef YY_STDINIT
1921 java_in = stdin;
1922 java_out = stdout;
1923 #else
1924 java_in = (FILE *) 0;
1925 java_out = (FILE *) 0;
1926 #endif
1927
1928 /* For future reference: Set errno on error, since we are called by
1929 * java_lex_init()
1930 */
1931 return 0;
1932 }
1933
1934 /* java_lex_destroy is for both reentrant and non-reentrant scanners. */
1935 int java_lex_destroy (void)
1936 {
1937
1938 /* Pop the buffer stack, destroying each element. */
1939 while(YY_CURRENT_BUFFER){
1940 java__delete_buffer(YY_CURRENT_BUFFER );
1941 YY_CURRENT_BUFFER_LVALUE = NULL;
1942 java_pop_buffer_state();
1943 }
1944
1945 /* Destroy the stack itself. */
1946 java_free((yy_buffer_stack) );
1947 (yy_buffer_stack) = NULL;
1948
1949 /* Destroy the start condition stack. */
1950 java_free((yy_start_stack) );
1951 (yy_start_stack) = NULL;
1952
1953 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1954 * java_lex() is called, initialization will occur. */
1955 yy_init_globals( );
1956
1957 return 0;
1958 }
1959
1960 /*
1961 * Internal utility routines.
1962 */
1963
1964 #ifndef yytext_ptr
1965 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1966 {
1967 register int i;
1968 for ( i = 0; i < n; ++i )
1969 s1[i] = s2[i];
1970 }
1971 #endif
1972
1973 #ifdef YY_NEED_STRLEN
1974 static int yy_flex_strlen (yyconst char * s )
1975 {
1976 register int n;
1977 for ( n = 0; s[n]; ++n )
1978 ;
1979
1980 return n;
1981 }
1982 #endif
1983
1984 void *java_alloc (yy_size_t size )
1985 {
1986 return (void *) malloc( size );
1987 }
1988
1989 void *java_realloc (void * ptr, yy_size_t size )
1990 {
1991 /* The cast to (char *) in the following accommodates both
1992 * implementations that use char* generic pointers, and those
1993 * that use void* generic pointers. It works with the latter
1994 * because both ANSI C and C++ allow castless assignment from
1995 * any pointer type to void*, and deal with argument conversions
1996 * as though doing an assignment.
1997 */
1998 return (void *) realloc( (char *) ptr, size );
1999 }
2000
2001 void java_free (void * ptr )
2002 {
2003 free( (char *) ptr ); /* see java_realloc() for (char *) cast */
2004 }
2005
2006 #define YYTABLES_NAME "yytables"
2007
2008 #line 113 "java.l"
2009
2010
2011 void
2012 java_parser_init(FILE *ip)
2013 {
2014 DEFAULT_BEGIN_OF_FILE_ACTION
2015 BEGIN JAVA;
2016 }
2017
/* ![[top]](../icons/top.png)
![[bottom]](../icons/n_bottom.png)
*/