1 #include "cmStandardIncludes.h"
2 #line 2 "cmDependsJavaLexer.cxx"
4 #line 4 "cmDependsJavaLexer.cxx"
6 #define YY_INT_ALIGNED short int
8 /* A lexical scanner generated by flex */
11 #define YY_FLEX_MAJOR_VERSION 2
12 #define YY_FLEX_MINOR_VERSION 5
13 #define YY_FLEX_SUBMINOR_VERSION 31
14 #if YY_FLEX_SUBMINOR_VERSION > 0
18 /* First, we deal with platform-specific or compiler-specific issues. */
20 /* begin standard C headers. */
26 #if defined(__BEOS__) || defined (__HAIKU__)
27 #include <unistd.h> /* prevents a conflict with a #define later on... */
30 /* end standard C headers. */
32 /* flex integer type definitions */
37 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
39 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
41 typedef int8_t flex_int8_t;
42 typedef uint8_t flex_uint8_t;
43 typedef int16_t flex_int16_t;
44 typedef uint16_t flex_uint16_t;
45 typedef int32_t flex_int32_t;
46 typedef uint32_t flex_uint32_t;
48 typedef signed char flex_int8_t;
49 typedef short int flex_int16_t;
50 typedef int flex_int32_t;
51 typedef unsigned char flex_uint8_t;
52 typedef unsigned short int flex_uint16_t;
53 typedef unsigned int flex_uint32_t;
56 /* Limits of integral types. */
58 #define INT8_MIN (-128)
61 #define INT16_MIN (-32767-1)
64 #define INT32_MIN (-2147483647-1)
67 #define INT8_MAX (127)
70 #define INT16_MAX (32767)
73 #define INT32_MAX (2147483647)
76 #define UINT8_MAX (255U)
79 #define UINT16_MAX (65535U)
82 #define UINT32_MAX (4294967295U)
85 #endif /* ! FLEXINT_H */
89 /* The "const" storage-class-modifier is valid. */
92 #else /* ! __cplusplus */
99 #endif /* ! __cplusplus */
102 #define yyconst const
107 /* Returned upon end-of-file. */
110 /* Promotes a possibly negative, possibly signed char to an unsigned
111 * integer for use as an array index. If the signed char is negative,
112 * we want to instead treat it as an 8-bit unsigned char, hence the
115 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
117 /* An opaque pointer. */
118 #ifndef YY_TYPEDEF_YY_SCANNER_T
119 #define YY_TYPEDEF_YY_SCANNER_T
120 typedef void* yyscan_t;
123 /* For convenience, these vars (plus the bison vars far below)
124 are macros in the reentrant scanner. */
125 #define yyin yyg->yyin_r
126 #define yyout yyg->yyout_r
127 #define yyextra yyg->yyextra_r
128 #define yyleng yyg->yyleng_r
129 #define yytext yyg->yytext_r
130 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
131 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
132 #define yy_flex_debug yyg->yy_flex_debug_r
134 int cmDependsJava_yylex_init (yyscan_t* scanner);
136 /* Enter a start condition. This macro really ought to take a parameter,
137 * but we do it the disgusting crufty way forced on us by the ()-less
138 * definition of BEGIN.
140 #define BEGIN yyg->yy_start = 1 + 2 *
142 /* Translate the current start state into a value that can be later handed
143 * to BEGIN to return to the state. The YYSTATE alias is for lex
146 #define YY_START ((yyg->yy_start - 1) / 2)
147 #define YYSTATE YY_START
149 /* Action number for EOF rule of a given start state. */
150 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
152 /* Special action meaning "start processing a new file". */
153 #define YY_NEW_FILE cmDependsJava_yyrestart(yyin ,yyscanner )
155 #define YY_END_OF_BUFFER_CHAR 0
157 /* Size of default input buffer. */
159 #define YY_BUF_SIZE 16384
162 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
163 #define YY_TYPEDEF_YY_BUFFER_STATE
164 typedef struct yy_buffer_state *YY_BUFFER_STATE;
167 #define EOB_ACT_CONTINUE_SCAN 0
168 #define EOB_ACT_END_OF_FILE 1
169 #define EOB_ACT_LAST_MATCH 2
171 #define YY_LESS_LINENO(n)
173 /* Return all but the first "n" matched characters back to the input stream. */
177 /* Undo effects of setting up yytext. */ \
178 int yyless_macro_arg = (n); \
179 YY_LESS_LINENO(yyless_macro_arg);\
180 *yy_cp = yyg->yy_hold_char; \
181 YY_RESTORE_YY_MORE_OFFSET \
182 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
183 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
187 /* The following is because we cannot portably get our hands on size_t
188 * (without autoconf's help, which isn't available because we want
189 * flex-generated scanners to compile on their own).
192 #ifndef YY_TYPEDEF_YY_SIZE_T
193 #define YY_TYPEDEF_YY_SIZE_T
194 typedef unsigned int yy_size_t;
197 #ifndef YY_STRUCT_YY_BUFFER_STATE
198 #define YY_STRUCT_YY_BUFFER_STATE
199 struct yy_buffer_state
203 char *yy_ch_buf; /* input buffer */
204 char *yy_buf_pos; /* current position in input buffer */
206 /* Size of input buffer in bytes, not including room for EOB
209 yy_size_t yy_buf_size;
211 /* Number of characters read into yy_ch_buf, not including EOB
216 /* Whether we "own" the buffer - i.e., we know we created it,
217 * and can realloc() it to grow it, and should free() it to
220 int yy_is_our_buffer;
222 /* Whether this is an "interactive" input source; if so, and
223 * if we're using stdio for input, then we want to use getc()
224 * instead of fread(), to make sure we stop fetching input after
227 int yy_is_interactive;
229 /* Whether we're considered to be at the beginning of a line.
230 * If so, '^' rules will be active on the next match, otherwise
235 int yy_bs_lineno; /**< The line count. */
236 int yy_bs_column; /**< The column count. */
238 /* Whether to try to fill the input buffer when we reach the
243 int yy_buffer_status;
245 #define YY_BUFFER_NEW 0
246 #define YY_BUFFER_NORMAL 1
247 /* When an EOF's been seen but there's still some text to process
248 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
249 * shouldn't try reading from the input source any more. We might
250 * still have a bunch of tokens to match, though, because of
251 * possible backing-up.
253 * When we actually see the EOF, we change the status to "new"
254 * (via cmDependsJava_yyrestart()), so that the user can continue scanning by
255 * just pointing yyin at a new input file.
257 #define YY_BUFFER_EOF_PENDING 2
260 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
262 /* We provide macros for accessing buffer states in case in the
263 * future we want to put the buffer states in a more general
266 * Returns the top of the stack, or NULL.
268 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
269 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
272 /* Same as previous macro, but useful when we know that the buffer stack is not
273 * NULL or when we need an lvalue. For internal use only.
275 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
277 void cmDependsJava_yyrestart (FILE *input_file ,yyscan_t yyscanner );
278 void cmDependsJava_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
279 YY_BUFFER_STATE cmDependsJava_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
280 void cmDependsJava_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
281 void cmDependsJava_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
282 void cmDependsJava_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
283 void cmDependsJava_yypop_buffer_state (yyscan_t yyscanner );
285 static void cmDependsJava_yyensure_buffer_stack (yyscan_t yyscanner );
286 static void cmDependsJava_yy_load_buffer_state (yyscan_t yyscanner );
287 static void cmDependsJava_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
289 #define YY_FLUSH_BUFFER cmDependsJava_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
291 YY_BUFFER_STATE cmDependsJava_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
292 YY_BUFFER_STATE cmDependsJava_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
293 YY_BUFFER_STATE cmDependsJava_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
295 void *cmDependsJava_yyalloc (yy_size_t ,yyscan_t yyscanner );
296 void *cmDependsJava_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
297 void cmDependsJava_yyfree (void * ,yyscan_t yyscanner );
299 #define yy_new_buffer cmDependsJava_yy_create_buffer
301 #define yy_set_interactive(is_interactive) \
303 if ( ! YY_CURRENT_BUFFER ){ \
304 cmDependsJava_yyensure_buffer_stack (yyscanner); \
305 YY_CURRENT_BUFFER_LVALUE = \
306 cmDependsJava_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
308 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
311 #define yy_set_bol(at_bol) \
313 if ( ! YY_CURRENT_BUFFER ){\
314 cmDependsJava_yyensure_buffer_stack (yyscanner); \
315 YY_CURRENT_BUFFER_LVALUE = \
316 cmDependsJava_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
318 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
321 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
323 /* Begin user sect3 */
325 #define cmDependsJava_yywrap(n) 1
326 #define YY_SKIP_YYWRAP
328 typedef unsigned char YY_CHAR;
330 typedef int yy_state_type;
332 #define yytext_ptr yytext_r
334 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
335 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
336 static int yy_get_next_buffer (yyscan_t yyscanner );
337 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
339 /* Done after the current pattern has been matched and before the
340 * corresponding action - sets up yytext.
342 #define YY_DO_BEFORE_ACTION \
343 yyg->yytext_ptr = yy_bp; \
344 yyleng = (size_t) (yy_cp - yy_bp); \
345 yyg->yy_hold_char = *yy_cp; \
347 yyg->yy_c_buf_p = yy_cp;
349 #define YY_NUM_RULES 111
350 #define YY_END_OF_BUFFER 112
351 /* This struct is not used in this scanner,
352 but its presence is necessary. */
355 flex_int32_t yy_verify;
358 static yyconst flex_int16_t yy_accept[327] =
360 0, 0, 0, 0, 0, 0, 112, 110, 109, 109,
361 77, 4, 73, 94, 60, 110, 93, 92, 105, 99,
362 68, 89, 74, 71, 56, 56, 67, 103, 86, 75,
363 79, 102, 107, 64, 63, 65, 107, 107, 107, 107,
364 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
365 107, 70, 96, 69, 104, 3, 3, 6, 111, 5,
366 78, 95, 61, 62, 0, 0, 106, 101, 100, 91,
367 90, 57, 1, 0, 72, 57, 56, 57, 0, 56,
368 0, 88, 87, 76, 80, 81, 107, 66, 107, 107,
369 107, 107, 107, 107, 107, 107, 107, 107, 18, 107,
371 107, 107, 107, 107, 107, 26, 107, 107, 107, 107,
372 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
373 107, 107, 107, 107, 107, 97, 98, 2, 55, 55,
374 0, 0, 0, 108, 57, 0, 57, 58, 85, 82,
375 83, 107, 107, 107, 107, 107, 107, 107, 107, 107,
376 107, 107, 107, 107, 107, 107, 107, 107, 25, 107,
377 107, 30, 107, 107, 34, 107, 107, 107, 107, 107,
378 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
379 107, 50, 107, 107, 107, 0, 0, 58, 84, 107,
380 107, 107, 107, 11, 12, 107, 14, 107, 107, 107,
382 107, 20, 107, 107, 107, 107, 107, 107, 107, 107,
383 32, 107, 59, 107, 107, 107, 107, 107, 107, 107,
384 107, 107, 107, 107, 46, 107, 107, 54, 51, 107,
385 107, 107, 107, 107, 10, 13, 15, 107, 107, 107,
386 107, 22, 24, 107, 107, 107, 107, 107, 107, 107,
387 107, 107, 107, 40, 107, 107, 43, 107, 107, 47,
388 107, 107, 53, 107, 8, 107, 107, 107, 19, 107,
389 107, 107, 28, 107, 107, 33, 107, 107, 107, 38,
390 39, 41, 107, 44, 107, 48, 107, 107, 107, 9,
391 107, 17, 21, 23, 107, 107, 107, 35, 36, 107,
393 107, 107, 107, 107, 7, 16, 107, 107, 107, 107,
394 42, 107, 107, 52, 107, 107, 31, 37, 107, 49,
395 27, 29, 107, 107, 45, 0
398 static yyconst flex_int32_t yy_ec[256] =
400 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
401 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403 1, 2, 4, 5, 1, 6, 7, 8, 9, 10,
404 11, 12, 13, 14, 15, 16, 17, 18, 19, 19,
405 19, 19, 19, 19, 19, 20, 20, 21, 22, 23,
406 24, 25, 26, 1, 27, 27, 27, 28, 29, 28,
407 30, 30, 30, 30, 30, 31, 30, 30, 30, 30,
408 30, 30, 30, 30, 30, 30, 30, 32, 30, 30,
409 33, 34, 35, 36, 30, 1, 37, 38, 39, 40,
411 41, 42, 43, 44, 45, 30, 46, 47, 48, 49,
412 50, 51, 30, 52, 53, 54, 55, 56, 57, 58,
413 59, 60, 61, 62, 63, 64, 1, 1, 1, 1,
414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
430 static yyconst flex_int32_t yy_meta[65] =
432 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
433 1, 1, 1, 1, 1, 1, 1, 3, 3, 3,
434 1, 1, 1, 1, 1, 1, 3, 3, 3, 4,
435 4, 4, 1, 1, 1, 1, 3, 3, 3, 3,
436 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
437 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
441 static yyconst flex_int16_t yy_base[334] =
443 0, 0, 401, 400, 62, 63, 411, 414, 414, 414,
444 386, 414, 414, 385, 61, 374, 414, 414, 383, 57,
445 414, 56, 54, 65, 74, 43, 414, 414, 55, 382,
446 59, 414, 0, 414, 414, 381, 38, 36, 60, 46,
447 51, 75, 69, 354, 82, 76, 362, 85, 56, 352,
448 357, 414, 100, 414, 414, 414, 383, 414, 414, 414,
449 414, 414, 414, 414, 390, 127, 414, 414, 414, 414,
450 414, 129, 414, 395, 414, 132, 95, 414, 165, 414,
451 0, 373, 414, 414, 414, 109, 0, 414, 343, 342,
452 344, 352, 338, 101, 354, 353, 340, 346, 332, 333,
454 331, 337, 334, 332, 329, 0, 329, 110, 330, 324,
455 320, 329, 336, 93, 336, 319, 322, 89, 320, 325,
456 320, 114, 131, 120, 323, 414, 414, 414, 414, 358,
457 170, 357, 362, 414, 173, 157, 176, 150, 414, 414,
458 340, 309, 321, 314, 323, 318, 317, 318, 304, 302,
459 300, 316, 314, 310, 309, 296, 311, 310, 0, 153,
460 292, 304, 301, 298, 0, 295, 295, 284, 285, 291,
461 282, 284, 281, 289, 292, 278, 292, 277, 279, 279,
462 286, 0, 286, 288, 277, 189, 314, 414, 414, 270,
463 269, 279, 273, 0, 0, 274, 0, 264, 271, 260,
465 267, 0, 264, 271, 264, 256, 268, 256, 270, 254,
466 0, 249, 0, 267, 266, 261, 256, 248, 245, 253,
467 258, 244, 256, 250, 0, 236, 239, 0, 0, 237,
468 249, 252, 234, 250, 0, 0, 0, 237, 238, 243,
469 243, 235, 0, 233, 226, 230, 236, 236, 233, 221,
470 235, 234, 223, 0, 232, 216, 0, 225, 216, 214,
471 221, 220, 0, 225, 0, 214, 207, 207, 0, 207,
472 200, 217, 0, 218, 219, 0, 214, 213, 199, 0,
473 0, 0, 210, 0, 201, 0, 209, 202, 194, 0,
474 206, 0, 0, 0, 197, 204, 205, 0, 0, 202,
476 191, 192, 191, 198, 0, 0, 163, 162, 170, 170,
477 0, 164, 152, 0, 152, 157, 0, 0, 127, 0,
478 0, 0, 115, 95, 0, 414, 218, 222, 226, 228,
482 static yyconst flex_int16_t yy_def[334] =
484 326, 1, 327, 327, 328, 328, 326, 326, 326, 326,
485 326, 326, 326, 326, 326, 329, 326, 326, 326, 326,
486 326, 326, 326, 326, 326, 25, 326, 326, 326, 326,
487 326, 326, 330, 326, 326, 326, 330, 330, 330, 330,
488 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
489 330, 326, 326, 326, 326, 326, 326, 326, 326, 326,
490 326, 326, 326, 326, 326, 329, 326, 326, 326, 326,
491 326, 326, 326, 331, 326, 326, 25, 326, 326, 326,
492 332, 326, 326, 326, 326, 326, 330, 326, 330, 330,
493 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
495 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
496 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
497 330, 330, 330, 330, 330, 326, 326, 326, 326, 326,
498 326, 333, 331, 326, 326, 326, 326, 332, 326, 326,
499 326, 330, 330, 330, 330, 330, 330, 330, 330, 330,
500 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
501 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
502 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
503 330, 330, 330, 330, 330, 326, 333, 326, 326, 330,
504 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
506 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
507 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
508 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
509 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
510 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
511 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
512 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
513 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
514 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
515 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
517 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
518 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
519 330, 330, 330, 330, 330, 0, 326, 326, 326, 326,
523 static yyconst flex_int16_t yy_nxt[479] =
525 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
526 18, 19, 20, 21, 22, 23, 24, 25, 26, 26,
527 27, 28, 29, 30, 31, 32, 33, 33, 33, 33,
528 33, 33, 34, 8, 35, 36, 37, 38, 39, 40,
529 41, 42, 33, 33, 43, 33, 44, 33, 45, 33,
530 46, 47, 48, 49, 33, 50, 51, 33, 33, 33,
531 52, 53, 54, 55, 59, 59, 60, 60, 63, 68,
532 70, 72, 72, 72, 326, 89, 73, 82, 83, 71,
533 69, 74, 85, 86, 64, 91, 98, 92, 75, 76,
534 90, 77, 77, 77, 93, 99, 94, 100, 138, 122,
536 326, 78, 79, 95, 80, 81, 96, 123, 101, 97,
537 106, 102, 113, 78, 79, 78, 107, 108, 110, 103,
538 80, 104, 111, 126, 105, 173, 326, 114, 117, 326,
539 115, 81, 140, 141, 325, 130, 112, 168, 118, 119,
540 174, 120, 169, 121, 131, 131, 72, 72, 72, 135,
541 135, 135, 326, 147, 148, 324, 78, 79, 178, 78,
542 79, 127, 161, 162, 183, 179, 184, 180, 78, 79,
543 78, 78, 79, 78, 137, 137, 137, 136, 129, 136,
544 188, 132, 137, 137, 137, 181, 323, 186, 186, 182,
545 135, 135, 135, 137, 137, 137, 188, 129, 322, 207,
547 78, 79, 208, 78, 321, 320, 186, 186, 319, 318,
548 317, 316, 78, 79, 78, 78, 315, 78, 56, 56,
549 56, 56, 58, 58, 58, 58, 65, 65, 65, 65,
550 87, 87, 133, 133, 133, 133, 187, 187, 314, 313,
551 312, 311, 310, 309, 308, 307, 306, 305, 304, 303,
552 302, 301, 300, 299, 298, 297, 296, 295, 294, 293,
553 292, 291, 290, 289, 288, 287, 286, 285, 284, 283,
554 282, 281, 280, 279, 278, 277, 276, 275, 274, 273,
555 272, 271, 270, 269, 268, 267, 266, 265, 264, 263,
556 262, 261, 260, 259, 258, 257, 256, 255, 254, 253,
558 252, 251, 250, 249, 248, 247, 246, 245, 244, 243,
559 242, 228, 241, 240, 239, 238, 237, 236, 235, 234,
560 233, 232, 129, 231, 230, 229, 228, 227, 226, 225,
561 224, 223, 222, 221, 220, 219, 218, 217, 216, 215,
562 214, 213, 212, 211, 210, 209, 206, 205, 204, 203,
563 202, 201, 200, 199, 198, 197, 196, 195, 194, 193,
564 192, 191, 190, 189, 134, 129, 129, 185, 177, 176,
565 175, 172, 171, 170, 167, 166, 165, 164, 163, 160,
566 159, 158, 157, 156, 155, 154, 153, 152, 151, 150,
567 149, 146, 145, 144, 143, 142, 139, 134, 129, 128,
569 125, 124, 116, 109, 88, 84, 67, 66, 62, 61,
570 326, 57, 57, 7, 326, 326, 326, 326, 326, 326,
571 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
572 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
573 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
574 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
575 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
576 326, 326, 326, 326, 326, 326, 326, 326
579 static yyconst flex_int16_t yy_chk[479] =
581 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
582 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
583 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
584 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
585 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
586 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
587 1, 1, 1, 1, 5, 6, 5, 6, 15, 20,
588 22, 23, 23, 23, 26, 37, 24, 29, 29, 22,
589 20, 24, 31, 31, 15, 38, 40, 38, 24, 25,
590 37, 25, 25, 25, 38, 40, 39, 41, 332, 49,
592 26, 25, 25, 39, 25, 25, 39, 49, 41, 39,
593 43, 42, 46, 25, 25, 25, 43, 43, 45, 42,
594 25, 42, 45, 53, 42, 118, 77, 46, 48, 66,
595 46, 25, 86, 86, 324, 66, 45, 114, 48, 48,
596 118, 48, 114, 48, 66, 66, 72, 72, 72, 76,
597 76, 76, 77, 94, 94, 323, 72, 72, 122, 76,
598 76, 53, 108, 108, 124, 122, 124, 123, 72, 72,
599 72, 76, 76, 76, 136, 136, 136, 79, 131, 79,
600 138, 66, 79, 79, 79, 123, 319, 131, 131, 123,
601 135, 135, 135, 137, 137, 137, 138, 186, 316, 160,
603 135, 135, 160, 137, 315, 313, 186, 186, 312, 310,
604 309, 308, 135, 135, 135, 137, 307, 137, 327, 327,
605 327, 327, 328, 328, 328, 328, 329, 329, 329, 329,
606 330, 330, 331, 331, 331, 331, 333, 333, 304, 303,
607 302, 301, 300, 297, 296, 295, 291, 289, 288, 287,
608 285, 283, 279, 278, 277, 275, 274, 272, 271, 270,
609 268, 267, 266, 264, 262, 261, 260, 259, 258, 256,
610 255, 253, 252, 251, 250, 249, 248, 247, 246, 245,
611 244, 242, 241, 240, 239, 238, 234, 233, 232, 231,
612 230, 227, 226, 224, 223, 222, 221, 220, 219, 218,
614 217, 216, 215, 214, 212, 210, 209, 208, 207, 206,
615 205, 204, 203, 201, 200, 199, 198, 196, 193, 192,
616 191, 190, 187, 185, 184, 183, 181, 180, 179, 178,
617 177, 176, 175, 174, 173, 172, 171, 170, 169, 168,
618 167, 166, 164, 163, 162, 161, 158, 157, 156, 155,
619 154, 153, 152, 151, 150, 149, 148, 147, 146, 145,
620 144, 143, 142, 141, 133, 132, 130, 125, 121, 120,
621 119, 117, 116, 115, 113, 112, 111, 110, 109, 107,
622 105, 104, 103, 102, 101, 100, 99, 98, 97, 96,
623 95, 93, 92, 91, 90, 89, 82, 74, 65, 57,
625 51, 50, 47, 44, 36, 30, 19, 16, 14, 11,
626 7, 4, 3, 326, 326, 326, 326, 326, 326, 326,
627 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
628 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
629 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
630 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
631 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
632 326, 326, 326, 326, 326, 326, 326, 326
635 /* The intent behind this definition is that it'll catch
636 * any uses of REJECT which flex missed.
638 #define REJECT reject_used_but_not_detected
639 #define yymore() yymore_used_but_not_detected
640 #define YY_MORE_ADJ 0
641 #define YY_RESTORE_YY_MORE_OFFSET
642 #line 1 "cmDependsJavaLexer.in.l"
643 #line 2 "cmDependsJavaLexer.in.l"
644 /*============================================================================
645 CMake - Cross Platform Makefile Generator
646 Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
648 Distributed under the OSI-approved BSD License (the "License");
649 see accompanying file Copyright.txt for details.
651 This software is distributed WITHOUT ANY WARRANTY; without even the
652 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
653 See the License for more information.
654 ============================================================================*/
657 This file must be translated to C and modified to build everywhere.
661 flex --prefix=cmDependsJava_yy --header-file=cmDependsJavaLexer.h -ocmDependsJavaLexer.cxx cmDependsJavaLexer.in.l
663 Modify cmDependsJavaLexer.c:
665 - remove "yyscanner" argument from these methods:
666 yy_fatal_error, cmDependsJava_yyalloc, cmDependsJava_yyrealloc, cmDependsJava_yyfree
667 - remove all YY_BREAK lines occurring right after return statements
668 - change while ( 1 ) to for(;;)
670 Modify cmDependsJavaLexer.h:
672 - remove the yy_init_globals function
673 - remove the block that includes unistd.h
674 - remove #line directives (avoids bogus warning on old Sun)
678 #include "cmStandardLexer.h"
680 #include "cmDependsJavaParserHelper.h"
682 /* Replace the lexer input function. */
684 #define YY_INPUT(buf, result, max_size) \
685 { result = yyextra->LexInput(buf, max_size); }
687 /* Include the set of tokens from the parser. */
688 #include "cmDependsJavaParserTokens.h"
690 #define KEYWORD yylvalp->str = 0
691 #define SYMBOL yylvalp->str = 0
692 #define PRIMITIVE yylvalp->str = 0
694 /*--------------------------------------------------------------------------*/
697 #line 721 "cmDependsJavaLexer.cxx"
703 #ifndef YY_NO_UNISTD_H
704 /* Special case for "unistd.h", since it is non-ANSI. We include it way
705 * down here because we want the user's section 1 to have been scanned first.
706 * The user has a chance to override it with an option.
711 #ifndef YY_EXTRA_TYPE
712 #define YY_EXTRA_TYPE void *
715 /* Holds the entire state of the reentrant scanner. */
719 /* User-defined. Not touched by flex. */
720 YY_EXTRA_TYPE yyextra_r;
722 /* The rest are the same as the globals declared in the non-reentrant scanner. */
723 FILE *yyin_r, *yyout_r;
724 size_t yy_buffer_stack_top; /**< index of top of stack. */
725 size_t yy_buffer_stack_max; /**< capacity of stack. */
726 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
733 int yy_did_buffer_switch_on_eof;
734 int yy_start_stack_ptr;
735 int yy_start_stack_depth;
737 yy_state_type yy_last_accepting_state;
738 char* yy_last_accepting_cpos;
747 }; /* end struct yyguts_t */
749 /* Accessor methods to globals.
750 These are made visible to non-reentrant scanners for convenience. */
752 int cmDependsJava_yylex_destroy (yyscan_t yyscanner );
754 int cmDependsJava_yyget_debug (yyscan_t yyscanner );
756 void cmDependsJava_yyset_debug (int debug_flag ,yyscan_t yyscanner );
758 YY_EXTRA_TYPE cmDependsJava_yyget_extra (yyscan_t yyscanner );
760 void cmDependsJava_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
762 FILE *cmDependsJava_yyget_in (yyscan_t yyscanner );
764 void cmDependsJava_yyset_in (FILE * in_str ,yyscan_t yyscanner );
766 FILE *cmDependsJava_yyget_out (yyscan_t yyscanner );
768 void cmDependsJava_yyset_out (FILE * out_str ,yyscan_t yyscanner );
770 int cmDependsJava_yyget_leng (yyscan_t yyscanner );
772 char *cmDependsJava_yyget_text (yyscan_t yyscanner );
774 int cmDependsJava_yyget_lineno (yyscan_t yyscanner );
776 void cmDependsJava_yyset_lineno (int line_number ,yyscan_t yyscanner );
778 /* Macros after this point can all be overridden by user definitions in
782 #ifndef YY_SKIP_YYWRAP
784 extern "C" int cmDependsJava_yywrap (yyscan_t yyscanner );
786 extern int cmDependsJava_yywrap (yyscan_t yyscanner );
791 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
794 #ifdef YY_NEED_STRLEN
795 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
801 static int yyinput (yyscan_t yyscanner );
803 static int input (yyscan_t yyscanner );
808 /* Amount of stuff to slurp up with each read. */
809 #ifndef YY_READ_BUF_SIZE
810 #define YY_READ_BUF_SIZE 8192
813 /* Copy whatever the last rule matched to the standard output. */
815 /* This used to be an fputs(), but since the string might contain NUL's,
816 * we now use fwrite().
818 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
821 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
822 * is returned in "result".
825 #define YY_INPUT(buf,result,max_size) \
826 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
830 for ( n = 0; n < max_size && \
831 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
834 buf[n++] = (char) c; \
835 if ( c == EOF && ferror( yyin ) ) \
836 YY_FATAL_ERROR( "input in flex scanner failed" ); \
842 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
844 if( errno != EINTR) \
846 YY_FATAL_ERROR( "input in flex scanner failed" ); \
857 /* No semi-colon after return; correct usage is to write "yyterminate();" -
858 * we don't want an extra ';' after the "return" because that will cause
859 * some compilers to complain about unreachable statements.
862 #define yyterminate() return YY_NULL
865 /* Number of entries by which start-condition stack grows. */
866 #ifndef YY_START_STACK_INCR
867 #define YY_START_STACK_INCR 25
870 /* Report a fatal error. */
871 #ifndef YY_FATAL_ERROR
872 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
875 /* end tables serialization structures and prototypes */
877 /* Default declaration of generated scanner - a define so the user can
878 * easily add parameters.
881 #define YY_DECL_IS_OURS 1
883 extern int cmDependsJava_yylex (yyscan_t yyscanner);
885 #define YY_DECL int cmDependsJava_yylex (yyscan_t yyscanner)
886 #endif /* !YY_DECL */
888 /* Code executed at the beginning of each rule, after yytext and yyleng
891 #ifndef YY_USER_ACTION
892 #define YY_USER_ACTION
895 /* Code executed at the end of each rule. */
897 #define YY_BREAK break;
900 #define YY_RULE_SETUP \
903 /** The main scanner function which does all the work.
907 register yy_state_type yy_current_state;
908 register char *yy_cp, *yy_bp;
910 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
912 #line 88 "cmDependsJavaLexer.in.l"
914 #line 940 "cmDependsJavaLexer.cxx"
924 if ( ! yyg->yy_start )
925 yyg->yy_start = 1; /* first start state */
933 if ( ! YY_CURRENT_BUFFER ) {
934 cmDependsJava_yyensure_buffer_stack (yyscanner);
935 YY_CURRENT_BUFFER_LVALUE =
936 cmDependsJava_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
939 cmDependsJava_yy_load_buffer_state(yyscanner );
942 for(;;) /* loops until end-of-file is reached */
944 yy_cp = yyg->yy_c_buf_p;
946 /* Support of yytext. */
947 *yy_cp = yyg->yy_hold_char;
949 /* yy_bp points to the position in yy_ch_buf of the start of
954 yy_current_state = yyg->yy_start;
958 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
959 if ( yy_accept[yy_current_state] )
961 yyg->yy_last_accepting_state = yy_current_state;
962 yyg->yy_last_accepting_cpos = yy_cp;
964 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
966 yy_current_state = (int) yy_def[yy_current_state];
967 if ( yy_current_state >= 327 )
968 yy_c = yy_meta[(unsigned int) yy_c];
970 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
973 while ( yy_base[yy_current_state] != 414 );
976 yy_act = yy_accept[yy_current_state];
978 { /* have to back up */
979 yy_cp = yyg->yy_last_accepting_cpos;
980 yy_current_state = yyg->yy_last_accepting_state;
981 yy_act = yy_accept[yy_current_state];
986 do_action: /* This label is used only to access EOF actions. */
989 { /* beginning of action switch */
990 case 0: /* must back up */
991 /* undo the effects of YY_DO_BEFORE_ACTION */
992 *yy_cp = yyg->yy_hold_char;
993 yy_cp = yyg->yy_last_accepting_cpos;
994 yy_current_state = yyg->yy_last_accepting_state;
999 #line 89 "cmDependsJavaLexer.in.l"
1004 #line 90 "cmDependsJavaLexer.in.l"
1008 /* rule 3 can match eol */
1010 #line 91 "cmDependsJavaLexer.in.l"
1015 #line 93 "cmDependsJavaLexer.in.l"
1020 #line 94 "cmDependsJavaLexer.in.l"
1021 { BEGIN(INITIAL); return jp_STRINGLITERAL; }
1024 #line 95 "cmDependsJavaLexer.in.l"
1029 #line 97 "cmDependsJavaLexer.in.l"
1030 { KEYWORD; return jp_ABSTRACT; }
1033 #line 98 "cmDependsJavaLexer.in.l"
1034 { KEYWORD; return jp_ASSERT; }
1037 #line 99 "cmDependsJavaLexer.in.l"
1038 { KEYWORD; return jp_BOOLEAN_TYPE; }
1041 #line 100 "cmDependsJavaLexer.in.l"
1042 { KEYWORD; return jp_BREAK; }
1045 #line 101 "cmDependsJavaLexer.in.l"
1046 { KEYWORD; return jp_BYTE_TYPE; }
1049 #line 102 "cmDependsJavaLexer.in.l"
1050 { KEYWORD; return jp_CASE; }
1053 #line 103 "cmDependsJavaLexer.in.l"
1054 { KEYWORD; return jp_CATCH; }
1057 #line 104 "cmDependsJavaLexer.in.l"
1058 { KEYWORD; return jp_CHAR_TYPE; }
1061 #line 105 "cmDependsJavaLexer.in.l"
1062 { KEYWORD; return jp_CLASS; }
1065 #line 106 "cmDependsJavaLexer.in.l"
1066 { KEYWORD; return jp_CONTINUE; }
1069 #line 107 "cmDependsJavaLexer.in.l"
1070 { KEYWORD; return jp_DEFAULT; }
1073 #line 108 "cmDependsJavaLexer.in.l"
1074 { KEYWORD; return jp_DO; }
1077 #line 109 "cmDependsJavaLexer.in.l"
1078 { KEYWORD; return jp_DOUBLE_TYPE; }
1081 #line 110 "cmDependsJavaLexer.in.l"
1082 { KEYWORD; return jp_ELSE; }
1085 #line 111 "cmDependsJavaLexer.in.l"
1086 { KEYWORD; return jp_EXTENDS; }
1089 #line 112 "cmDependsJavaLexer.in.l"
1090 { KEYWORD; return jp_FINAL; }
1093 #line 113 "cmDependsJavaLexer.in.l"
1094 { KEYWORD; return jp_FINALLY; }
1097 #line 114 "cmDependsJavaLexer.in.l"
1098 { KEYWORD; return jp_FLOAT_TYPE; }
1101 #line 115 "cmDependsJavaLexer.in.l"
1102 { KEYWORD; return jp_FOR; }
1105 #line 116 "cmDependsJavaLexer.in.l"
1106 { KEYWORD; return jp_IF; }
1109 #line 117 "cmDependsJavaLexer.in.l"
1110 { KEYWORD; return jp_IMPLEMENTS; }
1113 #line 118 "cmDependsJavaLexer.in.l"
1114 { KEYWORD; return jp_IMPORT; }
1117 #line 119 "cmDependsJavaLexer.in.l"
1118 { KEYWORD; return jp_INSTANCEOF; }
1121 #line 120 "cmDependsJavaLexer.in.l"
1122 { KEYWORD; return jp_INT_TYPE; }
1125 #line 121 "cmDependsJavaLexer.in.l"
1126 { KEYWORD; return jp_INTERFACE; }
1129 #line 122 "cmDependsJavaLexer.in.l"
1130 { KEYWORD; return jp_LONG_TYPE; }
1133 #line 123 "cmDependsJavaLexer.in.l"
1134 { KEYWORD; return jp_NATIVE; }
1137 #line 124 "cmDependsJavaLexer.in.l"
1138 { KEYWORD; return jp_NEW; }
1141 #line 125 "cmDependsJavaLexer.in.l"
1142 { KEYWORD; return jp_PACKAGE; }
1145 #line 126 "cmDependsJavaLexer.in.l"
1146 { KEYWORD; return jp_PRIVATE; }
1149 #line 127 "cmDependsJavaLexer.in.l"
1150 { KEYWORD; return jp_PROTECTED; }
1153 #line 128 "cmDependsJavaLexer.in.l"
1154 { KEYWORD; return jp_PUBLIC; }
1157 #line 129 "cmDependsJavaLexer.in.l"
1158 { KEYWORD; return jp_RETURN; }
1161 #line 130 "cmDependsJavaLexer.in.l"
1162 { KEYWORD; return jp_SHORT_TYPE; }
1165 #line 131 "cmDependsJavaLexer.in.l"
1166 { KEYWORD; return jp_STATIC; }
1169 #line 132 "cmDependsJavaLexer.in.l"
1170 { KEYWORD; return jp_STRICTFP; }
1173 #line 133 "cmDependsJavaLexer.in.l"
1174 { KEYWORD; return jp_SUPER; }
1177 #line 134 "cmDependsJavaLexer.in.l"
1178 { KEYWORD; return jp_SWITCH; }
1181 #line 135 "cmDependsJavaLexer.in.l"
1182 { KEYWORD; return jp_SYNCHRONIZED; }
1185 #line 136 "cmDependsJavaLexer.in.l"
1186 { KEYWORD; return jp_THIS; }
1189 #line 137 "cmDependsJavaLexer.in.l"
1190 { KEYWORD; return jp_THROW; }
1193 #line 138 "cmDependsJavaLexer.in.l"
1194 { KEYWORD; return jp_THROWS; }
1197 #line 139 "cmDependsJavaLexer.in.l"
1198 { KEYWORD; return jp_TRANSIENT; }
1201 #line 140 "cmDependsJavaLexer.in.l"
1202 { KEYWORD; return jp_TRY; }
1205 #line 141 "cmDependsJavaLexer.in.l"
1206 { KEYWORD; return jp_VOID; }
1209 #line 142 "cmDependsJavaLexer.in.l"
1210 { KEYWORD; return jp_VOLATILE; }
1213 #line 143 "cmDependsJavaLexer.in.l"
1214 { KEYWORD; return jp_WHILE; }
1217 #line 145 "cmDependsJavaLexer.in.l"
1218 { PRIMITIVE; return jp_BOOLEANLITERAL; }
1220 /* rule 55 can match eol */
1222 #line 146 "cmDependsJavaLexer.in.l"
1223 { PRIMITIVE; return jp_CHARACTERLITERAL; }
1226 #line 147 "cmDependsJavaLexer.in.l"
1227 { PRIMITIVE; return jp_DECIMALINTEGERLITERAL; }
1230 #line 148 "cmDependsJavaLexer.in.l"
1231 { PRIMITIVE; return jp_FLOATINGPOINTLITERAL; }
1234 #line 149 "cmDependsJavaLexer.in.l"
1235 { PRIMITIVE; return jp_HEXINTEGERLITERAL; }
1238 #line 150 "cmDependsJavaLexer.in.l"
1239 { PRIMITIVE; return jp_NULLLITERAL; }
1242 #line 152 "cmDependsJavaLexer.in.l"
1243 { SYMBOL; return jp_AND; }
1246 #line 153 "cmDependsJavaLexer.in.l"
1247 { SYMBOL; return jp_ANDAND; }
1250 #line 154 "cmDependsJavaLexer.in.l"
1251 { SYMBOL; return jp_ANDEQUALS; }
1254 #line 155 "cmDependsJavaLexer.in.l"
1255 { SYMBOL; return jp_BRACKETEND; }
1258 #line 156 "cmDependsJavaLexer.in.l"
1259 { SYMBOL; return jp_BRACKETSTART; }
1262 #line 157 "cmDependsJavaLexer.in.l"
1263 { SYMBOL; return jp_CARROT; }
1266 #line 158 "cmDependsJavaLexer.in.l"
1267 { SYMBOL; return jp_CARROTEQUALS; }
1270 #line 159 "cmDependsJavaLexer.in.l"
1271 { SYMBOL; return jp_COLON; }
1274 #line 160 "cmDependsJavaLexer.in.l"
1275 { SYMBOL; return jp_COMMA; }
1278 #line 161 "cmDependsJavaLexer.in.l"
1279 { SYMBOL; return jp_CURLYEND; }
1282 #line 162 "cmDependsJavaLexer.in.l"
1283 { SYMBOL; return jp_CURLYSTART; }
1286 #line 163 "cmDependsJavaLexer.in.l"
1287 { SYMBOL; return jp_DIVIDE; }
1290 #line 164 "cmDependsJavaLexer.in.l"
1291 { SYMBOL; return jp_DIVIDEEQUALS; }
1294 #line 165 "cmDependsJavaLexer.in.l"
1295 { SYMBOL; return jp_DOLLAR; }
1298 #line 166 "cmDependsJavaLexer.in.l"
1299 { SYMBOL; return jp_DOT; }
1302 #line 167 "cmDependsJavaLexer.in.l"
1303 { SYMBOL; return jp_EQUALS; }
1306 #line 168 "cmDependsJavaLexer.in.l"
1307 { SYMBOL; return jp_EQUALSEQUALS; }
1310 #line 169 "cmDependsJavaLexer.in.l"
1311 { SYMBOL; return jp_EXCLAMATION; }
1314 #line 170 "cmDependsJavaLexer.in.l"
1315 { SYMBOL; return jp_EXCLAMATIONEQUALS; }
1318 #line 171 "cmDependsJavaLexer.in.l"
1319 { SYMBOL; return jp_GREATER; }
1322 #line 172 "cmDependsJavaLexer.in.l"
1323 { SYMBOL; return jp_GTEQUALS; }
1326 #line 173 "cmDependsJavaLexer.in.l"
1327 { SYMBOL; return jp_GTGT; }
1330 #line 174 "cmDependsJavaLexer.in.l"
1331 { SYMBOL; return jp_GTGTEQUALS; }
1334 #line 175 "cmDependsJavaLexer.in.l"
1335 { SYMBOL; return jp_GTGTGT; }
1338 #line 176 "cmDependsJavaLexer.in.l"
1339 { SYMBOL; return jp_GTGTGTEQUALS; }
1342 #line 177 "cmDependsJavaLexer.in.l"
1343 { SYMBOL; return jp_LESLESEQUALS; }
1346 #line 178 "cmDependsJavaLexer.in.l"
1347 { SYMBOL; return jp_LESSTHAN; }
1350 #line 179 "cmDependsJavaLexer.in.l"
1351 { SYMBOL; return jp_LTEQUALS; }
1354 #line 180 "cmDependsJavaLexer.in.l"
1355 { SYMBOL; return jp_LTLT; }
1358 #line 181 "cmDependsJavaLexer.in.l"
1359 { SYMBOL; return jp_MINUS; }
1362 #line 182 "cmDependsJavaLexer.in.l"
1363 { SYMBOL; return jp_MINUSEQUALS; }
1366 #line 183 "cmDependsJavaLexer.in.l"
1367 { SYMBOL; return jp_MINUSMINUS; }
1370 #line 184 "cmDependsJavaLexer.in.l"
1371 { SYMBOL; return jp_PAREEND; }
1374 #line 185 "cmDependsJavaLexer.in.l"
1375 { SYMBOL; return jp_PARESTART; }
1378 #line 186 "cmDependsJavaLexer.in.l"
1379 { SYMBOL; return jp_PERCENT; }
1382 #line 187 "cmDependsJavaLexer.in.l"
1383 { SYMBOL; return jp_PERCENTEQUALS; }
1386 #line 188 "cmDependsJavaLexer.in.l"
1387 { SYMBOL; return jp_PIPE; }
1390 #line 189 "cmDependsJavaLexer.in.l"
1391 { SYMBOL; return jp_PIPEEQUALS; }
1394 #line 190 "cmDependsJavaLexer.in.l"
1395 { SYMBOL; return jp_PIPEPIPE; }
1398 #line 191 "cmDependsJavaLexer.in.l"
1399 { SYMBOL; return jp_PLUS; }
1402 #line 192 "cmDependsJavaLexer.in.l"
1403 { SYMBOL; return jp_PLUSEQUALS; }
1406 #line 193 "cmDependsJavaLexer.in.l"
1407 { SYMBOL; return jp_PLUSPLUS; }
1410 #line 194 "cmDependsJavaLexer.in.l"
1411 { SYMBOL; return jp_QUESTION; }
1414 #line 195 "cmDependsJavaLexer.in.l"
1415 { SYMBOL; return jp_SEMICOL; }
1418 #line 196 "cmDependsJavaLexer.in.l"
1419 { SYMBOL; return jp_TILDE; }
1422 #line 197 "cmDependsJavaLexer.in.l"
1423 { SYMBOL; return jp_TIMES; }
1426 #line 198 "cmDependsJavaLexer.in.l"
1427 { SYMBOL; return jp_TIMESEQUALS; }
1430 #line 200 "cmDependsJavaLexer.in.l"
1432 yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
1436 /* rule 108 can match eol */
1438 #line 205 "cmDependsJavaLexer.in.l"
1442 /* rule 109 can match eol */
1444 #line 206 "cmDependsJavaLexer.in.l"
1449 #line 207 "cmDependsJavaLexer.in.l"
1451 std::cerr << "Unknown character: " << yytext[0]
1452 << " (" << (int)yytext[0] << ")" << std::endl;
1453 yyextra->Error("Unknown character");
1458 #line 214 "cmDependsJavaLexer.in.l"
1461 #line 1590 "cmDependsJavaLexer.cxx"
1462 case YY_STATE_EOF(INITIAL):
1463 case YY_STATE_EOF(comment):
1464 case YY_STATE_EOF(string):
1467 case YY_END_OF_BUFFER:
1469 /* Amount of text matched not including the EOB char. */
1470 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1472 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1473 *yy_cp = yyg->yy_hold_char;
1474 YY_RESTORE_YY_MORE_OFFSET
1476 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1478 /* We're scanning a new file or input source. It's
1479 * possible that this happened because the user
1480 * just pointed yyin at a new source and called
1481 * cmDependsJava_yylex(). If so, then we have to assure
1482 * consistency between YY_CURRENT_BUFFER and our
1483 * globals. Here is the right place to do so, because
1484 * this is the first action (other than possibly a
1485 * back-up) that will match for the new input source.
1487 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1488 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1489 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1492 /* Note that here we test for yy_c_buf_p "<=" to the position
1493 * of the first EOB in the buffer, since yy_c_buf_p will
1494 * already have been incremented past the NUL character
1495 * (since all states make transitions on EOB to the
1496 * end-of-buffer state). Contrast this with the test
1499 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1500 { /* This was really a NUL. */
1501 yy_state_type yy_next_state;
1503 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1505 yy_current_state = yy_get_previous_state( yyscanner );
1507 /* Okay, we're now positioned to make the NUL
1508 * transition. We couldn't have
1509 * yy_get_previous_state() go ahead and do it
1510 * for us because it doesn't know how to deal
1511 * with the possibility of jamming (and we don't
1512 * want to build jamming into it because then it
1513 * will run more slowly).
1516 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1518 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1520 if ( yy_next_state )
1522 /* Consume the NUL. */
1523 yy_cp = ++yyg->yy_c_buf_p;
1524 yy_current_state = yy_next_state;
1530 yy_cp = yyg->yy_c_buf_p;
1531 goto yy_find_action;
1535 else switch ( yy_get_next_buffer( yyscanner ) )
1537 case EOB_ACT_END_OF_FILE:
1539 yyg->yy_did_buffer_switch_on_eof = 0;
1541 if ( cmDependsJava_yywrap(yyscanner ) )
1543 /* Note: because we've taken care in
1544 * yy_get_next_buffer() to have set up
1545 * yytext, we can now set up
1546 * yy_c_buf_p so that if some total
1547 * hoser (like flex itself) wants to
1548 * call the scanner after we return the
1549 * YY_NULL, it'll still work - another
1550 * YY_NULL will get returned.
1552 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1554 yy_act = YY_STATE_EOF(YY_START);
1560 if ( ! yyg->yy_did_buffer_switch_on_eof )
1566 case EOB_ACT_CONTINUE_SCAN:
1568 yyg->yytext_ptr + yy_amount_of_matched_text;
1570 yy_current_state = yy_get_previous_state( yyscanner );
1572 yy_cp = yyg->yy_c_buf_p;
1573 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1576 case EOB_ACT_LAST_MATCH:
1578 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1580 yy_current_state = yy_get_previous_state( yyscanner );
1582 yy_cp = yyg->yy_c_buf_p;
1583 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1584 goto yy_find_action;
1591 "fatal flex scanner internal error--no action found" );
1592 } /* end of action switch */
1593 } /* end of scanning one token */
1594 return 0; /* this should not happen but it silences a warning*/
1595 } /* end of cmDependsJava_yylex */
1597 /* yy_get_next_buffer - try to read in a new buffer
1599 * Returns a code representing an action:
1600 * EOB_ACT_LAST_MATCH -
1601 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1602 * EOB_ACT_END_OF_FILE - end of file
1604 static int yy_get_next_buffer (yyscan_t yyscanner)
1606 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1607 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1608 register char *source = yyg->yytext_ptr;
1609 register int number_to_move, i;
1612 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1614 "fatal flex scanner internal error--end of buffer missed" );
1616 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1617 { /* Don't try to fill the buffer, so this is an EOF. */
1618 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1620 /* We matched a single character, the EOB, so
1621 * treat this as a final EOF.
1623 return EOB_ACT_END_OF_FILE;
1628 /* We matched some text prior to the EOB, first
1631 return EOB_ACT_LAST_MATCH;
1635 /* Try to read more data. */
1637 /* First move last chars to start of buffer. */
1638 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1640 for ( i = 0; i < number_to_move; ++i )
1641 *(dest++) = *(source++);
1643 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1644 /* don't do the read, it's not guaranteed to return an EOF,
1647 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1652 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1654 while ( nuto_read <= 0 )
1655 { /* Not enough room in the buffer - grow it. */
1657 /* just a shorter name for the current buffer */
1658 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1660 int yy_c_buf_p_offset =
1661 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1663 if ( b->yy_is_our_buffer )
1665 int new_size = b->yy_buf_size * 2;
1667 if ( new_size <= 0 )
1668 b->yy_buf_size += b->yy_buf_size / 8;
1670 b->yy_buf_size *= 2;
1672 b->yy_ch_buf = (char *)
1673 /* Include room in for 2 EOB chars. */
1674 cmDependsJava_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1677 /* Can't grow it, we don't own it. */
1680 if ( ! b->yy_ch_buf )
1682 "fatal error - scanner input buffer overflow" );
1684 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1686 nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1691 if ( nuto_read > YY_READ_BUF_SIZE )
1692 nuto_read = YY_READ_BUF_SIZE;
1694 /* Read in more data. */
1695 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1696 yyg->yy_n_chars, nuto_read );
1698 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1701 if ( yyg->yy_n_chars == 0 )
1703 if ( number_to_move == YY_MORE_ADJ )
1705 ret_val = EOB_ACT_END_OF_FILE;
1706 cmDependsJava_yyrestart(yyin ,yyscanner);
1711 ret_val = EOB_ACT_LAST_MATCH;
1712 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1713 YY_BUFFER_EOF_PENDING;
1718 ret_val = EOB_ACT_CONTINUE_SCAN;
1720 yyg->yy_n_chars += number_to_move;
1721 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1722 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1724 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1729 /* yy_get_previous_state - get the state just before the EOB char was reached */
1731 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1733 register yy_state_type yy_current_state;
1734 register char *yy_cp;
1735 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1737 yy_current_state = yyg->yy_start;
1739 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1741 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1742 if ( yy_accept[yy_current_state] )
1744 yyg->yy_last_accepting_state = yy_current_state;
1745 yyg->yy_last_accepting_cpos = yy_cp;
1747 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1749 yy_current_state = (int) yy_def[yy_current_state];
1750 if ( yy_current_state >= 327 )
1751 yy_c = yy_meta[(unsigned int) yy_c];
1753 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1756 return yy_current_state;
1759 /* yy_try_NUL_trans - try to make a transition on the NUL character
1762 * next_state = yy_try_NUL_trans( current_state );
1764 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1766 register int yy_is_jam;
1767 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1768 register char *yy_cp = yyg->yy_c_buf_p;
1770 register YY_CHAR yy_c = 1;
1771 if ( yy_accept[yy_current_state] )
1773 yyg->yy_last_accepting_state = yy_current_state;
1774 yyg->yy_last_accepting_cpos = yy_cp;
1776 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1778 yy_current_state = (int) yy_def[yy_current_state];
1779 if ( yy_current_state >= 327 )
1780 yy_c = yy_meta[(unsigned int) yy_c];
1782 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1783 yy_is_jam = (yy_current_state == 326);
1785 return yy_is_jam ? 0 : yy_current_state;
1790 static int yyinput (yyscan_t yyscanner)
1792 static int input (yyscan_t yyscanner)
1797 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1799 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1801 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1803 /* yy_c_buf_p now points to the character we want to return.
1804 * If this occurs *before* the EOB characters, then it's a
1805 * valid NUL; if not, then we've hit the end of the buffer.
1807 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1808 /* This was really a NUL. */
1809 *yyg->yy_c_buf_p = '\0';
1812 { /* need more input */
1813 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1816 switch ( yy_get_next_buffer( yyscanner ) )
1818 case EOB_ACT_LAST_MATCH:
1819 /* This happens because yy_g_n_b()
1820 * sees that we've accumulated a
1821 * token and flags that we need to
1822 * try matching the token before
1823 * proceeding. But for input(),
1824 * there's no matching to consider.
1825 * So convert the EOB_ACT_LAST_MATCH
1826 * to EOB_ACT_END_OF_FILE.
1829 /* Reset buffer status. */
1830 cmDependsJava_yyrestart(yyin ,yyscanner);
1834 case EOB_ACT_END_OF_FILE:
1836 if ( cmDependsJava_yywrap(yyscanner ) )
1839 if ( ! yyg->yy_did_buffer_switch_on_eof )
1842 return yyinput(yyscanner);
1844 return input(yyscanner);
1848 case EOB_ACT_CONTINUE_SCAN:
1849 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1855 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1856 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
1857 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1861 #endif /* ifndef YY_NO_INPUT */
1863 /** Immediately switch to a different input stream.
1864 * @param input_file A readable stream.
1865 * @param yyscanner The scanner object.
1866 * @note This function does not reset the start condition to @c INITIAL .
1868 void cmDependsJava_yyrestart (FILE * input_file , yyscan_t yyscanner)
1870 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1872 if ( ! YY_CURRENT_BUFFER ){
1873 cmDependsJava_yyensure_buffer_stack (yyscanner);
1874 YY_CURRENT_BUFFER_LVALUE =
1875 cmDependsJava_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1878 cmDependsJava_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1879 cmDependsJava_yy_load_buffer_state(yyscanner );
1882 /** Switch to a different input buffer.
1883 * @param new_buffer The new input buffer.
1884 * @param yyscanner The scanner object.
1886 void cmDependsJava_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1888 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1890 /* TODO. We should be able to replace this entire function body
1892 * cmDependsJava_yypop_buffer_state();
1893 * cmDependsJava_yypush_buffer_state(new_buffer);
1895 cmDependsJava_yyensure_buffer_stack (yyscanner);
1896 if ( YY_CURRENT_BUFFER == new_buffer )
1899 if ( YY_CURRENT_BUFFER )
1901 /* Flush out information for old buffer. */
1902 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1903 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1904 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1907 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1908 cmDependsJava_yy_load_buffer_state(yyscanner );
1910 /* We don't actually know whether we did this switch during
1911 * EOF (cmDependsJava_yywrap()) processing, but the only time this flag
1912 * is looked at is after cmDependsJava_yywrap() is called, so it's safe
1913 * to go ahead and always set it.
1915 yyg->yy_did_buffer_switch_on_eof = 1;
1918 static void cmDependsJava_yy_load_buffer_state (yyscan_t yyscanner)
1920 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1921 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1922 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1923 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1924 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1927 /** Allocate and initialize an input buffer state.
1928 * @param file A readable stream.
1929 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1930 * @param yyscanner The scanner object.
1931 * @return the allocated buffer state.
1933 YY_BUFFER_STATE cmDependsJava_yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
1937 b = (YY_BUFFER_STATE) cmDependsJava_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1939 YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_create_buffer()" );
1941 b->yy_buf_size = size;
1943 /* yy_ch_buf has to be 2 characters longer than the size given because
1944 * we need to put in 2 end-of-buffer characters.
1946 b->yy_ch_buf = (char *) cmDependsJava_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1947 if ( ! b->yy_ch_buf )
1948 YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_create_buffer()" );
1950 b->yy_is_our_buffer = 1;
1952 cmDependsJava_yy_init_buffer(b,file ,yyscanner);
1957 /** Destroy the buffer.
1958 * @param b a buffer created with cmDependsJava_yy_create_buffer()
1959 * @param yyscanner The scanner object.
1961 void cmDependsJava_yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1963 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1968 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1969 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1971 if ( b->yy_is_our_buffer )
1972 cmDependsJava_yyfree((void *) b->yy_ch_buf ,yyscanner );
1974 cmDependsJava_yyfree((void *) b ,yyscanner );
1978 extern int isatty (int );
1979 #endif /* __cplusplus */
1981 /* Initializes or reinitializes a buffer.
1982 * This function is sometimes called more than once on the same buffer,
1983 * such as during a cmDependsJava_yyrestart() or at EOF.
1985 static void cmDependsJava_yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1989 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1991 cmDependsJava_yy_flush_buffer(b ,yyscanner);
1993 b->yy_input_file = file;
1994 b->yy_fill_buffer = 1;
1996 /* If b is the current buffer, then cmDependsJava_yy_init_buffer was _probably_
1997 * called from cmDependsJava_yyrestart() or through yy_get_next_buffer.
1998 * In that case, we don't want to reset the lineno or column.
2000 if (b != YY_CURRENT_BUFFER){
2001 b->yy_bs_lineno = 1;
2002 b->yy_bs_column = 0;
2005 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2010 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2011 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2012 * @param yyscanner The scanner object.
2014 void cmDependsJava_yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2016 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2022 /* We always need two end-of-buffer characters. The first causes
2023 * a transition to the end-of-buffer state. The second causes
2024 * a jam in that state.
2026 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2027 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2029 b->yy_buf_pos = &b->yy_ch_buf[0];
2032 b->yy_buffer_status = YY_BUFFER_NEW;
2034 if ( b == YY_CURRENT_BUFFER )
2035 cmDependsJava_yy_load_buffer_state(yyscanner );
2038 /** Pushes the new state onto the stack. The new state becomes
2039 * the current state. This function will allocate the stack
2041 * @param new_buffer The new state.
2042 * @param yyscanner The scanner object.
2044 void cmDependsJava_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2046 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2047 if (new_buffer == NULL)
2050 cmDependsJava_yyensure_buffer_stack(yyscanner);
2052 /* This block is copied from cmDependsJava_yy_switch_to_buffer. */
2053 if ( YY_CURRENT_BUFFER )
2055 /* Flush out information for old buffer. */
2056 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2057 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2058 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2061 /* Only push if top exists. Otherwise, replace top. */
2062 if (YY_CURRENT_BUFFER)
2063 yyg->yy_buffer_stack_top++;
2064 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2066 /* copied from cmDependsJava_yy_switch_to_buffer. */
2067 cmDependsJava_yy_load_buffer_state(yyscanner );
2068 yyg->yy_did_buffer_switch_on_eof = 1;
2071 /** Removes and deletes the top of the stack, if present.
2072 * The next element becomes the new top.
2073 * @param yyscanner The scanner object.
2075 void cmDependsJava_yypop_buffer_state (yyscan_t yyscanner)
2077 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2078 if (!YY_CURRENT_BUFFER)
2081 cmDependsJava_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2082 YY_CURRENT_BUFFER_LVALUE = NULL;
2083 if (yyg->yy_buffer_stack_top > 0)
2084 --yyg->yy_buffer_stack_top;
2086 if (YY_CURRENT_BUFFER) {
2087 cmDependsJava_yy_load_buffer_state(yyscanner );
2088 yyg->yy_did_buffer_switch_on_eof = 1;
2092 /* Allocates the stack if it does not exist.
2093 * Guarantees space for at least one push.
2095 static void cmDependsJava_yyensure_buffer_stack (yyscan_t yyscanner)
2098 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2100 if (!yyg->yy_buffer_stack) {
2102 /* First allocation is just for 2 elements, since we don't know if this
2103 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2104 * immediate realloc on the next call.
2107 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsJava_yyalloc
2108 (nuto_alloc * sizeof(struct yy_buffer_state*)
2111 memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
2113 yyg->yy_buffer_stack_max = nuto_alloc;
2114 yyg->yy_buffer_stack_top = 0;
2118 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2120 /* Increase the buffer to prepare for a possible push. */
2121 int grow_size = 8 /* arbitrary grow size */;
2123 nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
2124 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsJava_yyrealloc
2125 (yyg->yy_buffer_stack,
2126 nuto_alloc * sizeof(struct yy_buffer_state*)
2129 /* zero only the new slots.*/
2130 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2131 yyg->yy_buffer_stack_max = nuto_alloc;
2135 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2136 * @param base the character buffer
2137 * @param size the size in bytes of the character buffer
2138 * @param yyscanner The scanner object.
2139 * @return the newly allocated buffer state object.
2141 YY_BUFFER_STATE cmDependsJava_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
2146 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2147 base[size-1] != YY_END_OF_BUFFER_CHAR )
2148 /* They forgot to leave room for the EOB's. */
2151 b = (YY_BUFFER_STATE) cmDependsJava_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2153 YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_scan_buffer()" );
2155 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2156 b->yy_buf_pos = b->yy_ch_buf = base;
2157 b->yy_is_our_buffer = 0;
2158 b->yy_input_file = 0;
2159 b->yy_n_chars = b->yy_buf_size;
2160 b->yy_is_interactive = 0;
2162 b->yy_fill_buffer = 0;
2163 b->yy_buffer_status = YY_BUFFER_NEW;
2165 cmDependsJava_yy_switch_to_buffer(b ,yyscanner );
2170 /** Setup the input buffer state to scan a string. The next call to cmDependsJava_yylex() will
2171 * scan from a @e copy of @a yy_str.
2172 * @param yy_str a NUL-terminated string to scan
2173 * @param yyscanner The scanner object.
2174 * @return the newly allocated buffer state object.
2175 * @note If you want to scan bytes that may contain NUL values, then use
2176 * cmDependsJava_yy_scan_bytes() instead.
2178 YY_BUFFER_STATE cmDependsJava_yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
2181 return cmDependsJava_yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
2184 /** Setup the input buffer state to scan the given bytes. The next call to cmDependsJava_yylex() will
2185 * scan from a @e copy of @a bytes.
2186 * @param bytes the byte buffer to scan
2187 * @param len the number of bytes in the buffer pointed to by @a bytes.
2188 * @param yyscanner The scanner object.
2189 * @return the newly allocated buffer state object.
2191 YY_BUFFER_STATE cmDependsJava_yy_scan_bytes (yyconst char * bytes, int len , yyscan_t yyscanner)
2198 /* Get memory for full buffer, including space for trailing EOB's. */
2200 buf = (char *) cmDependsJava_yyalloc(n ,yyscanner );
2202 YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_scan_bytes()" );
2204 for ( i = 0; i < len; ++i )
2207 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2209 b = cmDependsJava_yy_scan_buffer(buf,n ,yyscanner);
2211 YY_FATAL_ERROR( "bad buffer in cmDependsJava_yy_scan_bytes()" );
2213 /* It's okay to grow etc. this buffer, and we should throw it
2214 * away when we're done.
2216 b->yy_is_our_buffer = 1;
2221 #ifndef YY_EXIT_FAILURE
2222 #define YY_EXIT_FAILURE 2
2225 static void yy_fatal_error (yyconst char* msg , yyscan_t)
2227 (void) fprintf( stderr, "%s\n", msg );
2228 exit( YY_EXIT_FAILURE );
2231 /* Redefine yyless() so it works in section 3 code. */
2237 /* Undo effects of setting up yytext. */ \
2238 int yyless_macro_arg = (n); \
2239 YY_LESS_LINENO(yyless_macro_arg);\
2240 yytext[yyleng] = yyg->yy_hold_char; \
2241 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2242 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2243 *yyg->yy_c_buf_p = '\0'; \
2244 yyleng = yyless_macro_arg; \
2248 /* Accessor methods (get/set functions) to struct members. */
2250 /** Get the user-defined data for this scanner.
2251 * @param yyscanner The scanner object.
2253 YY_EXTRA_TYPE cmDependsJava_yyget_extra (yyscan_t yyscanner)
2255 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2259 /** Get the current line number.
2260 * @param yyscanner The scanner object.
2262 int cmDependsJava_yyget_lineno (yyscan_t yyscanner)
2264 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2266 if (! YY_CURRENT_BUFFER)
2272 /** Get the current column number.
2273 * @param yyscanner The scanner object.
2275 int cmDependsJava_yyget_column (yyscan_t yyscanner)
2277 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2279 if (! YY_CURRENT_BUFFER)
2285 /** Get the input stream.
2286 * @param yyscanner The scanner object.
2288 FILE *cmDependsJava_yyget_in (yyscan_t yyscanner)
2290 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2294 /** Get the output stream.
2295 * @param yyscanner The scanner object.
2297 FILE *cmDependsJava_yyget_out (yyscan_t yyscanner)
2299 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2303 /** Get the length of the current token.
2304 * @param yyscanner The scanner object.
2306 int cmDependsJava_yyget_leng (yyscan_t yyscanner)
2308 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2312 /** Get the current token.
2313 * @param yyscanner The scanner object.
2316 char *cmDependsJava_yyget_text (yyscan_t yyscanner)
2318 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2322 /** Set the user-defined data. This data is never touched by the scanner.
2323 * @param user_defined The data to be associated with this scanner.
2324 * @param yyscanner The scanner object.
2326 void cmDependsJava_yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2328 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2329 yyextra = user_defined ;
2332 /** Set the current line number.
2333 * @param line_number
2334 * @param yyscanner The scanner object.
2336 void cmDependsJava_yyset_lineno (int line_number , yyscan_t yyscanner)
2338 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2340 /* lineno is only valid if an input buffer exists. */
2341 if (! YY_CURRENT_BUFFER )
2342 yy_fatal_error( "cmDependsJava_yyset_lineno called with no buffer" , yyscanner);
2344 yylineno = line_number;
2347 /** Set the current column.
2349 * @param yyscanner The scanner object.
2351 void cmDependsJava_yyset_column (int column_no , yyscan_t yyscanner)
2353 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2355 /* column is only valid if an input buffer exists. */
2356 if (! YY_CURRENT_BUFFER )
2357 yy_fatal_error( "cmDependsJava_yyset_column called with no buffer" , yyscanner);
2359 yycolumn = column_no;
2362 /** Set the input stream. This does not discard the current
2364 * @param in_str A readable stream.
2365 * @param yyscanner The scanner object.
2366 * @see cmDependsJava_yy_switch_to_buffer
2368 void cmDependsJava_yyset_in (FILE * in_str , yyscan_t yyscanner)
2370 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2374 void cmDependsJava_yyset_out (FILE * out_str , yyscan_t yyscanner)
2376 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2380 int cmDependsJava_yyget_debug (yyscan_t yyscanner)
2382 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2383 return yy_flex_debug;
2386 void cmDependsJava_yyset_debug (int bdebug , yyscan_t yyscanner)
2388 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2389 yy_flex_debug = bdebug ;
2392 /* Accessor methods for yylval and yylloc */
2394 static int yy_init_globals (yyscan_t yyscanner)
2396 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2397 /* Initialization is the same as for the non-reentrant scanner.
2398 This function is called once per scanner lifetime. */
2400 yyg->yy_buffer_stack = 0;
2401 yyg->yy_buffer_stack_top = 0;
2402 yyg->yy_buffer_stack_max = 0;
2403 yyg->yy_c_buf_p = (char *) 0;
2406 yyg->yy_start_stack_ptr = 0;
2407 yyg->yy_start_stack_depth = 0;
2408 yyg->yy_start_stack = (int *) 0;
2410 /* Defined in main.c */
2419 /* For future reference: Set errno on error, since we are called by
2420 * cmDependsJava_yylex_init()
2425 /* User-visible API */
2427 /* cmDependsJava_yylex_init is special because it creates the scanner itself, so it is
2428 * the ONLY reentrant function that doesn't take the scanner as the last argument.
2429 * That's why we explicitly handle the declaration, instead of using our macros.
2432 int cmDependsJava_yylex_init(yyscan_t* ptr_yy_globals)
2435 if (ptr_yy_globals == NULL){
2440 *ptr_yy_globals = (yyscan_t) cmDependsJava_yyalloc ( sizeof( struct yyguts_t ), NULL );
2442 if (*ptr_yy_globals == NULL){
2447 memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2449 return yy_init_globals ( *ptr_yy_globals );
2452 /* cmDependsJava_yylex_destroy is for both reentrant and non-reentrant scanners. */
2453 int cmDependsJava_yylex_destroy (yyscan_t yyscanner)
2455 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2457 /* Pop the buffer stack, destroying each element. */
2458 while(YY_CURRENT_BUFFER){
2459 cmDependsJava_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2460 YY_CURRENT_BUFFER_LVALUE = NULL;
2461 cmDependsJava_yypop_buffer_state(yyscanner);
2464 /* Destroy the stack itself. */
2465 cmDependsJava_yyfree(yyg->yy_buffer_stack ,yyscanner);
2466 yyg->yy_buffer_stack = NULL;
2468 /* Destroy the start condition stack. */
2469 cmDependsJava_yyfree(yyg->yy_start_stack ,yyscanner );
2470 yyg->yy_start_stack = NULL;
2472 /* Destroy the main struct (reentrant only). */
2473 cmDependsJava_yyfree ( yyscanner , yyscanner );
2478 * Internal utility routines.
2482 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2485 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2486 for ( i = 0; i < n; ++i )
2491 #ifdef YY_NEED_STRLEN
2492 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2495 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2496 for ( n = 0; s[n]; ++n )
2503 void *cmDependsJava_yyalloc (yy_size_t size , yyscan_t)
2505 return (void *) malloc( size );
2508 void *cmDependsJava_yyrealloc (void * ptr, yy_size_t size , yyscan_t)
2510 /* The cast to (char *) in the following accommodates both
2511 * implementations that use char* generic pointers, and those
2512 * that use void* generic pointers. It works with the latter
2513 * because both ANSI C and C++ allow castless assignment from
2514 * any pointer type to void*, and deal with argument conversions
2515 * as though doing an assignment.
2517 return (void *) realloc( (char *) ptr, size );
2520 void cmDependsJava_yyfree (void * ptr , yyscan_t)
2522 free( (char *) ptr ); /* see cmDependsJava_yyrealloc() for (char *) cast */
2525 #define YYTABLES_NAME "yytables"
2528 #undef YY_FLUSH_BUFFER
2530 #undef yy_new_buffer
2531 #undef yy_set_interactive
2533 #undef YY_DO_BEFORE_ACTION
2535 #ifdef YY_DECL_IS_OURS
2536 #undef YY_DECL_IS_OURS
2539 #line 214 "cmDependsJavaLexer.in.l"