Source/cmDependsJavaLexer.cxx

   1 #include "cmStandardIncludes.h"
   2 #line 2 "cmDependsJavaLexer.cxx"
   3
   4 #line 4 "cmDependsJavaLexer.cxx"
   5
   6 #define  YY_INT_ALIGNED short int
   7
   8 /* A lexical scanner generated by flex */
   9
  10 #define FLEX_SCANNER
  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
  15 #define FLEX_BETA
  16 #endif
  17
  18 /* First, we deal with  platform-specific or compiler-specific issues. */
  19
  20 /* begin standard C headers. */
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <stdlib.h>
  25
  26 #if defined(__BEOS__) || defined (__HAIKU__)
  27 #include <unistd.h>   /* prevents a conflict with a #define later on... */
  28 #endif
  29
  30 /* end standard C headers. */
  31
  32 /* flex integer type definitions */
  33
  34 #ifndef FLEXINT_H
  35 #define FLEXINT_H
  36
  37 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  38
  39 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
  40 #include <inttypes.h>
  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;
  47 #else
  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;
  54 #endif /* ! C99 */
  55
  56 /* Limits of integral types. */
  57 #ifndef INT8_MIN
  58 #define INT8_MIN               (-128)
  59 #endif
  60 #ifndef INT16_MIN
  61 #define INT16_MIN              (-32767-1)
  62 #endif
  63 #ifndef INT32_MIN
  64 #define INT32_MIN              (-2147483647-1)
  65 #endif
  66 #ifndef INT8_MAX
  67 #define INT8_MAX               (127)
  68 #endif
  69 #ifndef INT16_MAX
  70 #define INT16_MAX              (32767)
  71 #endif
  72 #ifndef INT32_MAX
  73 #define INT32_MAX              (2147483647)
  74 #endif
  75 #ifndef UINT8_MAX
  76 #define UINT8_MAX              (255U)
  77 #endif
  78 #ifndef UINT16_MAX
  79 #define UINT16_MAX             (65535U)
  80 #endif
  81 #ifndef UINT32_MAX
  82 #define UINT32_MAX             (4294967295U)
  83 #endif
  84
  85 #endif /* ! FLEXINT_H */
  86
  87 #ifdef __cplusplus
  88
  89 /* The "const" storage-class-modifier is valid. */
  90 #define YY_USE_CONST
  91
  92 #else  /* ! __cplusplus */
  93
  94 #if __STDC__
  95
  96 #define YY_USE_CONST
  97
  98 #endif  /* __STDC__ */
  99 #endif  /* ! __cplusplus */
 100
 101 #ifdef YY_USE_CONST
 102 #define yyconst const
 103 #else
 104 #define yyconst
 105 #endif
 106
 107 /* Returned upon end-of-file. */
 108 #define YY_NULL 0
 109
 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
 113  * double cast.
 114  */
 115 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 116
 117 /* An opaque pointer. */
 118 #ifndef YY_TYPEDEF_YY_SCANNER_T
 119 #define YY_TYPEDEF_YY_SCANNER_T
 120 typedef void* yyscan_t;
 121 #endif
 122
 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
 133
 134 int cmDependsJava_yylex_init (yyscan_t* scanner);
 135
 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.
 139  */
 140 #define BEGIN yyg->yy_start = 1 + 2 *
 141
 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
 144  * compatibility.
 145  */
 146 #define YY_START ((yyg->yy_start - 1) / 2)
 147 #define YYSTATE YY_START
 148
 149 /* Action number for EOF rule of a given start state. */
 150 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 151
 152 /* Special action meaning "start processing a new file". */
 153 #define YY_NEW_FILE cmDependsJava_yyrestart(yyin ,yyscanner )
 154
 155 #define YY_END_OF_BUFFER_CHAR 0
 156
 157 /* Size of default input buffer. */
 158 #ifndef YY_BUF_SIZE
 159 #define YY_BUF_SIZE 16384
 160 #endif
 161
 162 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 163 #define YY_TYPEDEF_YY_BUFFER_STATE
 164 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 165 #endif
 166
 167 #define EOB_ACT_CONTINUE_SCAN 0
 168 #define EOB_ACT_END_OF_FILE 1
 169 #define EOB_ACT_LAST_MATCH 2
 170
 171     #define YY_LESS_LINENO(n)
 172
 173 /* Return all but the first "n" matched characters back to the input stream. */
 174 #define yyless(n) \
 175   do \
 176     { \
 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 */ \
 184     } \
 185   while ( 0 )
 186
 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).
 190  */
 191
 192 #ifndef YY_TYPEDEF_YY_SIZE_T
 193 #define YY_TYPEDEF_YY_SIZE_T
 194 typedef unsigned int yy_size_t;
 195 #endif
 196
 197 #ifndef YY_STRUCT_YY_BUFFER_STATE
 198 #define YY_STRUCT_YY_BUFFER_STATE
 199 struct yy_buffer_state
 200   {
 201   FILE *yy_input_file;
 202
 203   char *yy_ch_buf;    /* input buffer */
 204   char *yy_buf_pos;    /* current position in input buffer */
 205
 206   /* Size of input buffer in bytes, not including room for EOB
 207    * characters.
 208    */
 209   yy_size_t yy_buf_size;
 210
 211   /* Number of characters read into yy_ch_buf, not including EOB
 212    * characters.
 213    */
 214   int yy_n_chars;
 215
 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
 218    * delete it.
 219    */
 220   int yy_is_our_buffer;
 221
 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
 225    * each newline.
 226    */
 227   int yy_is_interactive;
 228
 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
 231    * not.
 232    */
 233   int yy_at_bol;
 234
 235     int yy_bs_lineno; /**< The line count. */
 236     int yy_bs_column; /**< The column count. */
 237
 238   /* Whether to try to fill the input buffer when we reach the
 239    * end of it.
 240    */
 241   int yy_fill_buffer;
 242
 243   int yy_buffer_status;
 244
 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.
 252    *
 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.
 256    */
 257 #define YY_BUFFER_EOF_PENDING 2
 258
 259   };
 260 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 261
 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
 264  * "scanner state".
 265  *
 266  * Returns the top of the stack, or NULL.
 267  */
 268 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
 269                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
 270                           : NULL)
 271
 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.
 274  */
 275 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 276
 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 );
 284
 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 );
 288
 289 #define YY_FLUSH_BUFFER cmDependsJava_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 290
 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 );
 294
 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 );
 298
 299 #define yy_new_buffer cmDependsJava_yy_create_buffer
 300
 301 #define yy_set_interactive(is_interactive) \
 302   { \
 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); \
 307   } \
 308   YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 309   }
 310
 311 #define yy_set_bol(at_bol) \
 312   { \
 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); \
 317   } \
 318   YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 319   }
 320
 321 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 322
 323 /* Begin user sect3 */
 324
 325 #define cmDependsJava_yywrap(n) 1
 326 #define YY_SKIP_YYWRAP
 327
 328 typedef unsigned char YY_CHAR;
 329
 330 typedef int yy_state_type;
 331
 332 #define yytext_ptr yytext_r
 333
 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 );
 338
 339 /* Done after the current pattern has been matched and before the
 340  * corresponding action - sets up yytext.
 341  */
 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; \
 346   *yy_cp = '\0'; \
 347   yyg->yy_c_buf_p = yy_cp;
 348
 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. */
 353 struct yy_trans_info
 354   {
 355   flex_int32_t yy_verify;
 356   flex_int32_t yy_nxt;
 357   };
 358 static yyconst flex_int16_t yy_accept[327] =
 359     {   0,
 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,
 370
 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,
 381
 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,
 392
 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
 396     } ;
 397
 398 static yyconst flex_int32_t yy_ec[256] =
 399     {   0,
 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,
 410
 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,
 421
 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,
 427         1,    1,    1,    1,    1
 428     } ;
 429
 430 static yyconst flex_int32_t yy_meta[65] =
 431     {   0,
 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,
 438         1,    1,    1,    1
 439     } ;
 440
 441 static yyconst flex_int16_t yy_base[334] =
 442     {   0,
 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,
 453
 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,
 464
 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,
 475
 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,
 479       232,   96,  235
 480     } ;
 481
 482 static yyconst flex_int16_t yy_def[334] =
 483     {   0,
 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,
 494
 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,
 505
 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,
 516
 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,
 520       326,  326,  326
 521     } ;
 522
 523 static yyconst flex_int16_t yy_nxt[479] =
 524     {   0,
 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,
 535
 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,
 546
 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,
 557
 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,
 568
 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
 577     } ;
 578
 579 static yyconst flex_int16_t yy_chk[479] =
 580     {   0,
 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,
 591
 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,
 602
 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,
 613
 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,
 624
 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
 633     } ;
 634
 635 /* The intent behind this definition is that it'll catch
 636  * any uses of REJECT which flex missed.
 637  */
 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
 646   Program:   CMake - Cross-Platform Makefile Generator
 647   Module:    $RCSfile: cmDependsJavaLexer.cxx,v $
 648   Language:  C++
 649   Date:      $Date: 2008-09-15 21:53:27 $
 650   Version:   $Revision: 1.13 $
 651
 652   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
 653   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 654
 655      This software is distributed WITHOUT ANY WARRANTY; without even
 656      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 657      PURPOSE.  See the above copyright notices for more information.
 658
 659 =========================================================================*/
 660 /*
 661
 662 This file must be translated to C and modified to build everywhere.
 663
 664 Run flex like this:
 665
 666   flex --prefix=cmDependsJava_yy --header-file=cmDependsJavaLexer.h -ocmDependsJavaLexer.cxx cmDependsJavaLexer.in.l
 667
 668 Modify cmDependsJavaLexer.c:
 669   - remove TABs
 670   - remove "yyscanner" argument from these methods:
 671       yy_fatal_error, cmDependsJava_yyalloc, cmDependsJava_yyrealloc, cmDependsJava_yyfree
 672   - remove all YY_BREAK lines occurring right after return statements
 673   - change while ( 1 ) to for(;;)
 674
 675 Modify cmDependsJavaLexer.h:
 676   - remove TABs
 677   - remove the yy_init_globals function
 678   - remove the block that includes unistd.h
 679   - remove #line directives (avoids bogus warning on old Sun)
 680
 681 */
 682
 683 #include "cmStandardLexer.h"
 684
 685 #include "cmDependsJavaParserHelper.h"
 686
 687 /* Replace the lexer input function.  */
 688 #undef YY_INPUT
 689 #define YY_INPUT(buf, result, max_size) \
 690   { result = yyextra->LexInput(buf, max_size); }
 691
 692 /* Include the set of tokens from the parser.  */
 693 #include "cmDependsJavaParserTokens.h"
 694
 695 #define KEYWORD yylvalp->str = 0
 696 #define SYMBOL yylvalp->str = 0
 697 #define PRIMITIVE  yylvalp->str = 0
 698
 699 /*--------------------------------------------------------------------------*/
 700
 701
 702 #line 721 "cmDependsJavaLexer.cxx"
 703
 704 #define INITIAL 0
 705 #define comment 1
 706 #define string 2
 707
 708 #ifndef YY_NO_UNISTD_H
 709 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 710  * down here because we want the user's section 1 to have been scanned first.
 711  * The user has a chance to override it with an option.
 712  */
 713 #include <unistd.h>
 714 #endif
 715
 716 #ifndef YY_EXTRA_TYPE
 717 #define YY_EXTRA_TYPE void *
 718 #endif
 719
 720 /* Holds the entire state of the reentrant scanner. */
 721 struct yyguts_t
 722     {
 723
 724     /* User-defined. Not touched by flex. */
 725     YY_EXTRA_TYPE yyextra_r;
 726
 727     /* The rest are the same as the globals declared in the non-reentrant scanner. */
 728     FILE *yyin_r, *yyout_r;
 729     size_t yy_buffer_stack_top; /**< index of top of stack. */
 730     size_t yy_buffer_stack_max; /**< capacity of stack. */
 731     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
 732     char yy_hold_char;
 733     int yy_n_chars;
 734     int yyleng_r;
 735     char *yy_c_buf_p;
 736     int yy_init;
 737     int yy_start;
 738     int yy_did_buffer_switch_on_eof;
 739     int yy_start_stack_ptr;
 740     int yy_start_stack_depth;
 741     int *yy_start_stack;
 742     yy_state_type yy_last_accepting_state;
 743     char* yy_last_accepting_cpos;
 744
 745     int yylineno_r;
 746     int yy_flex_debug_r;
 747
 748     char *yytext_r;
 749     int yy_more_flag;
 750     int yy_more_len;
 751
 752     }; /* end struct yyguts_t */
 753
 754 /* Accessor methods to globals.
 755    These are made visible to non-reentrant scanners for convenience. */
 756
 757 int cmDependsJava_yylex_destroy (yyscan_t yyscanner );
 758
 759 int cmDependsJava_yyget_debug (yyscan_t yyscanner );
 760
 761 void cmDependsJava_yyset_debug (int debug_flag ,yyscan_t yyscanner );
 762
 763 YY_EXTRA_TYPE cmDependsJava_yyget_extra (yyscan_t yyscanner );
 764
 765 void cmDependsJava_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 766
 767 FILE *cmDependsJava_yyget_in (yyscan_t yyscanner );
 768
 769 void cmDependsJava_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
 770
 771 FILE *cmDependsJava_yyget_out (yyscan_t yyscanner );
 772
 773 void cmDependsJava_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 774
 775 int cmDependsJava_yyget_leng (yyscan_t yyscanner );
 776
 777 char *cmDependsJava_yyget_text (yyscan_t yyscanner );
 778
 779 int cmDependsJava_yyget_lineno (yyscan_t yyscanner );
 780
 781 void cmDependsJava_yyset_lineno (int line_number ,yyscan_t yyscanner );
 782
 783 /* Macros after this point can all be overridden by user definitions in
 784  * section 1.
 785  */
 786
 787 #ifndef YY_SKIP_YYWRAP
 788 #ifdef __cplusplus
 789 extern "C" int cmDependsJava_yywrap (yyscan_t yyscanner );
 790 #else
 791 extern int cmDependsJava_yywrap (yyscan_t yyscanner );
 792 #endif
 793 #endif
 794
 795 #ifndef yytext_ptr
 796 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 797 #endif
 798
 799 #ifdef YY_NEED_STRLEN
 800 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 801 #endif
 802
 803 #ifndef YY_NO_INPUT
 804
 805 #ifdef __cplusplus
 806 static int yyinput (yyscan_t yyscanner );
 807 #else
 808 static int input (yyscan_t yyscanner );
 809 #endif
 810
 811 #endif
 812
 813 /* Amount of stuff to slurp up with each read. */
 814 #ifndef YY_READ_BUF_SIZE
 815 #define YY_READ_BUF_SIZE 8192
 816 #endif
 817
 818 /* Copy whatever the last rule matched to the standard output. */
 819 #ifndef ECHO
 820 /* This used to be an fputs(), but since the string might contain NUL's,
 821  * we now use fwrite().
 822  */
 823 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 824 #endif
 825
 826 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 827  * is returned in "result".
 828  */
 829 #ifndef YY_INPUT
 830 #define YY_INPUT(buf,result,max_size) \
 831   if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 832     { \
 833     int c = '*'; \
 834     size_t n; \
 835     for ( n = 0; n < max_size && \
 836            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 837       buf[n] = (char) c; \
 838     if ( c == '\n' ) \
 839       buf[n++] = (char) c; \
 840     if ( c == EOF && ferror( yyin ) ) \
 841       YY_FATAL_ERROR( "input in flex scanner failed" ); \
 842     result = n; \
 843     } \
 844   else \
 845     { \
 846     errno=0; \
 847     while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 848       { \
 849       if( errno != EINTR) \
 850         { \
 851         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 852         break; \
 853         } \
 854       errno=0; \
 855       clearerr(yyin); \
 856       } \
 857     }\
 858 \
 859
 860 #endif
 861
 862 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 863  * we don't want an extra ';' after the "return" because that will cause
 864  * some compilers to complain about unreachable statements.
 865  */
 866 #ifndef yyterminate
 867 #define yyterminate() return YY_NULL
 868 #endif
 869
 870 /* Number of entries by which start-condition stack grows. */
 871 #ifndef YY_START_STACK_INCR
 872 #define YY_START_STACK_INCR 25
 873 #endif
 874
 875 /* Report a fatal error. */
 876 #ifndef YY_FATAL_ERROR
 877 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 878 #endif
 879
 880 /* end tables serialization structures and prototypes */
 881
 882 /* Default declaration of generated scanner - a define so the user can
 883  * easily add parameters.
 884  */
 885 #ifndef YY_DECL
 886 #define YY_DECL_IS_OURS 1
 887
 888 extern int cmDependsJava_yylex (yyscan_t yyscanner);
 889
 890 #define YY_DECL int cmDependsJava_yylex (yyscan_t yyscanner)
 891 #endif /* !YY_DECL */
 892
 893 /* Code executed at the beginning of each rule, after yytext and yyleng
 894  * have been set up.
 895  */
 896 #ifndef YY_USER_ACTION
 897 #define YY_USER_ACTION
 898 #endif
 899
 900 /* Code executed at the end of each rule. */
 901 #ifndef YY_BREAK
 902 #define YY_BREAK break;
 903 #endif
 904
 905 #define YY_RULE_SETUP \
 906   YY_USER_ACTION
 907
 908 /** The main scanner function which does all the work.
 909  */
 910 YY_DECL
 911 {
 912   register yy_state_type yy_current_state;
 913   register char *yy_cp, *yy_bp;
 914   register int yy_act;
 915     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 916
 917 #line 88 "cmDependsJavaLexer.in.l"
 918
 919 #line 940 "cmDependsJavaLexer.cxx"
 920
 921   if ( yyg->yy_init )
 922     {
 923     yyg->yy_init = 0;
 924
 925 #ifdef YY_USER_INIT
 926     YY_USER_INIT;
 927 #endif
 928
 929     if ( ! yyg->yy_start )
 930       yyg->yy_start = 1;  /* first start state */
 931
 932     if ( ! yyin )
 933       yyin = stdin;
 934
 935     if ( ! yyout )
 936       yyout = stdout;
 937
 938     if ( ! YY_CURRENT_BUFFER ) {
 939       cmDependsJava_yyensure_buffer_stack (yyscanner);
 940       YY_CURRENT_BUFFER_LVALUE =
 941         cmDependsJava_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 942     }
 943
 944     cmDependsJava_yy_load_buffer_state(yyscanner );
 945     }
 946
 947   for(;;)    /* loops until end-of-file is reached */
 948     {
 949     yy_cp = yyg->yy_c_buf_p;
 950
 951     /* Support of yytext. */
 952     *yy_cp = yyg->yy_hold_char;
 953
 954     /* yy_bp points to the position in yy_ch_buf of the start of
 955      * the current run.
 956      */
 957     yy_bp = yy_cp;
 958
 959     yy_current_state = yyg->yy_start;
 960 yy_match:
 961     do
 962       {
 963       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 964       if ( yy_accept[yy_current_state] )
 965         {
 966         yyg->yy_last_accepting_state = yy_current_state;
 967         yyg->yy_last_accepting_cpos = yy_cp;
 968         }
 969       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 970         {
 971         yy_current_state = (int) yy_def[yy_current_state];
 972         if ( yy_current_state >= 327 )
 973           yy_c = yy_meta[(unsigned int) yy_c];
 974         }
 975       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 976       ++yy_cp;
 977       }
 978     while ( yy_base[yy_current_state] != 414 );
 979
 980 yy_find_action:
 981     yy_act = yy_accept[yy_current_state];
 982     if ( yy_act == 0 )
 983       { /* have to back up */
 984       yy_cp = yyg->yy_last_accepting_cpos;
 985       yy_current_state = yyg->yy_last_accepting_state;
 986       yy_act = yy_accept[yy_current_state];
 987       }
 988
 989     YY_DO_BEFORE_ACTION;
 990
 991 do_action:  /* This label is used only to access EOF actions. */
 992
 993     switch ( yy_act )
 994   { /* beginning of action switch */
 995       case 0: /* must back up */
 996       /* undo the effects of YY_DO_BEFORE_ACTION */
 997       *yy_cp = yyg->yy_hold_char;
 998       yy_cp = yyg->yy_last_accepting_cpos;
 999       yy_current_state = yyg->yy_last_accepting_state;
1000       goto yy_find_action;
1001
1002 case 1:
1003 YY_RULE_SETUP
1004 #line 89 "cmDependsJavaLexer.in.l"
1005 { BEGIN(comment); }
1006   YY_BREAK
1007 case 2:
1008 YY_RULE_SETUP
1009 #line 90 "cmDependsJavaLexer.in.l"
1010 { BEGIN(INITIAL); }
1011   YY_BREAK
1012 case 3:
1013 /* rule 3 can match eol */
1014 YY_RULE_SETUP
1015 #line 91 "cmDependsJavaLexer.in.l"
1016 {}
1017   YY_BREAK
1018 case 4:
1019 YY_RULE_SETUP
1020 #line 93 "cmDependsJavaLexer.in.l"
1021 { BEGIN(string); }
1022   YY_BREAK
1023 case 5:
1024 YY_RULE_SETUP
1025 #line 94 "cmDependsJavaLexer.in.l"
1026 { BEGIN(INITIAL); return jp_STRINGLITERAL; }
1027 case 6:
1028 YY_RULE_SETUP
1029 #line 95 "cmDependsJavaLexer.in.l"
1030 {}
1031   YY_BREAK
1032 case 7:
1033 YY_RULE_SETUP
1034 #line 97 "cmDependsJavaLexer.in.l"
1035 { KEYWORD; return jp_ABSTRACT; }
1036 case 8:
1037 YY_RULE_SETUP
1038 #line 98 "cmDependsJavaLexer.in.l"
1039 { KEYWORD; return jp_ASSERT; }
1040 case 9:
1041 YY_RULE_SETUP
1042 #line 99 "cmDependsJavaLexer.in.l"
1043 { KEYWORD; return jp_BOOLEAN_TYPE; }
1044 case 10:
1045 YY_RULE_SETUP
1046 #line 100 "cmDependsJavaLexer.in.l"
1047 { KEYWORD; return jp_BREAK; }
1048 case 11:
1049 YY_RULE_SETUP
1050 #line 101 "cmDependsJavaLexer.in.l"
1051 { KEYWORD; return jp_BYTE_TYPE; }
1052 case 12:
1053 YY_RULE_SETUP
1054 #line 102 "cmDependsJavaLexer.in.l"
1055 { KEYWORD; return jp_CASE; }
1056 case 13:
1057 YY_RULE_SETUP
1058 #line 103 "cmDependsJavaLexer.in.l"
1059 { KEYWORD; return jp_CATCH; }
1060 case 14:
1061 YY_RULE_SETUP
1062 #line 104 "cmDependsJavaLexer.in.l"
1063 { KEYWORD; return jp_CHAR_TYPE; }
1064 case 15:
1065 YY_RULE_SETUP
1066 #line 105 "cmDependsJavaLexer.in.l"
1067 { KEYWORD; return jp_CLASS; }
1068 case 16:
1069 YY_RULE_SETUP
1070 #line 106 "cmDependsJavaLexer.in.l"
1071 { KEYWORD; return jp_CONTINUE; }
1072 case 17:
1073 YY_RULE_SETUP
1074 #line 107 "cmDependsJavaLexer.in.l"
1075 { KEYWORD; return jp_DEFAULT; }
1076 case 18:
1077 YY_RULE_SETUP
1078 #line 108 "cmDependsJavaLexer.in.l"
1079 { KEYWORD; return jp_DO; }
1080 case 19:
1081 YY_RULE_SETUP
1082 #line 109 "cmDependsJavaLexer.in.l"
1083 { KEYWORD; return jp_DOUBLE_TYPE; }
1084 case 20:
1085 YY_RULE_SETUP
1086 #line 110 "cmDependsJavaLexer.in.l"
1087 { KEYWORD; return jp_ELSE; }
1088 case 21:
1089 YY_RULE_SETUP
1090 #line 111 "cmDependsJavaLexer.in.l"
1091 { KEYWORD; return jp_EXTENDS; }
1092 case 22:
1093 YY_RULE_SETUP
1094 #line 112 "cmDependsJavaLexer.in.l"
1095 { KEYWORD; return jp_FINAL; }
1096 case 23:
1097 YY_RULE_SETUP
1098 #line 113 "cmDependsJavaLexer.in.l"
1099 { KEYWORD; return jp_FINALLY; }
1100 case 24:
1101 YY_RULE_SETUP
1102 #line 114 "cmDependsJavaLexer.in.l"
1103 { KEYWORD; return jp_FLOAT_TYPE; }
1104 case 25:
1105 YY_RULE_SETUP
1106 #line 115 "cmDependsJavaLexer.in.l"
1107 { KEYWORD; return jp_FOR; }
1108 case 26:
1109 YY_RULE_SETUP
1110 #line 116 "cmDependsJavaLexer.in.l"
1111 { KEYWORD; return jp_IF; }
1112 case 27:
1113 YY_RULE_SETUP
1114 #line 117 "cmDependsJavaLexer.in.l"
1115 { KEYWORD; return jp_IMPLEMENTS; }
1116 case 28:
1117 YY_RULE_SETUP
1118 #line 118 "cmDependsJavaLexer.in.l"
1119 { KEYWORD; return jp_IMPORT; }
1120 case 29:
1121 YY_RULE_SETUP
1122 #line 119 "cmDependsJavaLexer.in.l"
1123 { KEYWORD; return jp_INSTANCEOF; }
1124 case 30:
1125 YY_RULE_SETUP
1126 #line 120 "cmDependsJavaLexer.in.l"
1127 { KEYWORD; return jp_INT_TYPE; }
1128 case 31:
1129 YY_RULE_SETUP
1130 #line 121 "cmDependsJavaLexer.in.l"
1131 { KEYWORD; return jp_INTERFACE; }
1132 case 32:
1133 YY_RULE_SETUP
1134 #line 122 "cmDependsJavaLexer.in.l"
1135 { KEYWORD; return jp_LONG_TYPE; }
1136 case 33:
1137 YY_RULE_SETUP
1138 #line 123 "cmDependsJavaLexer.in.l"
1139 { KEYWORD; return jp_NATIVE; }
1140 case 34:
1141 YY_RULE_SETUP
1142 #line 124 "cmDependsJavaLexer.in.l"
1143 { KEYWORD; return jp_NEW; }
1144 case 35:
1145 YY_RULE_SETUP
1146 #line 125 "cmDependsJavaLexer.in.l"
1147 { KEYWORD; return jp_PACKAGE; }
1148 case 36:
1149 YY_RULE_SETUP
1150 #line 126 "cmDependsJavaLexer.in.l"
1151 { KEYWORD; return jp_PRIVATE; }
1152 case 37:
1153 YY_RULE_SETUP
1154 #line 127 "cmDependsJavaLexer.in.l"
1155 { KEYWORD; return jp_PROTECTED; }
1156 case 38:
1157 YY_RULE_SETUP
1158 #line 128 "cmDependsJavaLexer.in.l"
1159 { KEYWORD; return jp_PUBLIC; }
1160 case 39:
1161 YY_RULE_SETUP
1162 #line 129 "cmDependsJavaLexer.in.l"
1163 { KEYWORD; return jp_RETURN; }
1164 case 40:
1165 YY_RULE_SETUP
1166 #line 130 "cmDependsJavaLexer.in.l"
1167 { KEYWORD; return jp_SHORT_TYPE; }
1168 case 41:
1169 YY_RULE_SETUP
1170 #line 131 "cmDependsJavaLexer.in.l"
1171 { KEYWORD; return jp_STATIC; }
1172 case 42:
1173 YY_RULE_SETUP
1174 #line 132 "cmDependsJavaLexer.in.l"
1175 { KEYWORD; return jp_STRICTFP; }
1176 case 43:
1177 YY_RULE_SETUP
1178 #line 133 "cmDependsJavaLexer.in.l"
1179 { KEYWORD; return jp_SUPER; }
1180 case 44:
1181 YY_RULE_SETUP
1182 #line 134 "cmDependsJavaLexer.in.l"
1183 { KEYWORD; return jp_SWITCH; }
1184 case 45:
1185 YY_RULE_SETUP
1186 #line 135 "cmDependsJavaLexer.in.l"
1187 { KEYWORD; return jp_SYNCHRONIZED; }
1188 case 46:
1189 YY_RULE_SETUP
1190 #line 136 "cmDependsJavaLexer.in.l"
1191 { KEYWORD; return jp_THIS; }
1192 case 47:
1193 YY_RULE_SETUP
1194 #line 137 "cmDependsJavaLexer.in.l"
1195 { KEYWORD; return jp_THROW; }
1196 case 48:
1197 YY_RULE_SETUP
1198 #line 138 "cmDependsJavaLexer.in.l"
1199 { KEYWORD; return jp_THROWS; }
1200 case 49:
1201 YY_RULE_SETUP
1202 #line 139 "cmDependsJavaLexer.in.l"
1203 { KEYWORD; return jp_TRANSIENT; }
1204 case 50:
1205 YY_RULE_SETUP
1206 #line 140 "cmDependsJavaLexer.in.l"
1207 { KEYWORD; return jp_TRY; }
1208 case 51:
1209 YY_RULE_SETUP
1210 #line 141 "cmDependsJavaLexer.in.l"
1211 { KEYWORD; return jp_VOID; }
1212 case 52:
1213 YY_RULE_SETUP
1214 #line 142 "cmDependsJavaLexer.in.l"
1215 { KEYWORD; return jp_VOLATILE; }
1216 case 53:
1217 YY_RULE_SETUP
1218 #line 143 "cmDependsJavaLexer.in.l"
1219 { KEYWORD; return jp_WHILE; }
1220 case 54:
1221 YY_RULE_SETUP
1222 #line 145 "cmDependsJavaLexer.in.l"
1223 { PRIMITIVE; return jp_BOOLEANLITERAL; }
1224 case 55:
1225 /* rule 55 can match eol */
1226 YY_RULE_SETUP
1227 #line 146 "cmDependsJavaLexer.in.l"
1228 { PRIMITIVE; return jp_CHARACTERLITERAL; }
1229 case 56:
1230 YY_RULE_SETUP
1231 #line 147 "cmDependsJavaLexer.in.l"
1232 { PRIMITIVE; return jp_DECIMALINTEGERLITERAL; }
1233 case 57:
1234 YY_RULE_SETUP
1235 #line 148 "cmDependsJavaLexer.in.l"
1236 { PRIMITIVE; return jp_FLOATINGPOINTLITERAL; }
1237 case 58:
1238 YY_RULE_SETUP
1239 #line 149 "cmDependsJavaLexer.in.l"
1240 { PRIMITIVE; return jp_HEXINTEGERLITERAL; }
1241 case 59:
1242 YY_RULE_SETUP
1243 #line 150 "cmDependsJavaLexer.in.l"
1244 { PRIMITIVE; return jp_NULLLITERAL; }
1245 case 60:
1246 YY_RULE_SETUP
1247 #line 152 "cmDependsJavaLexer.in.l"
1248 { SYMBOL; return jp_AND; }
1249 case 61:
1250 YY_RULE_SETUP
1251 #line 153 "cmDependsJavaLexer.in.l"
1252 { SYMBOL; return jp_ANDAND; }
1253 case 62:
1254 YY_RULE_SETUP
1255 #line 154 "cmDependsJavaLexer.in.l"
1256 { SYMBOL; return jp_ANDEQUALS; }
1257 case 63:
1258 YY_RULE_SETUP
1259 #line 155 "cmDependsJavaLexer.in.l"
1260 { SYMBOL; return jp_BRACKETEND; }
1261 case 64:
1262 YY_RULE_SETUP
1263 #line 156 "cmDependsJavaLexer.in.l"
1264 { SYMBOL; return jp_BRACKETSTART; }
1265 case 65:
1266 YY_RULE_SETUP
1267 #line 157 "cmDependsJavaLexer.in.l"
1268 { SYMBOL; return jp_CARROT; }
1269 case 66:
1270 YY_RULE_SETUP
1271 #line 158 "cmDependsJavaLexer.in.l"
1272 { SYMBOL; return jp_CARROTEQUALS; }
1273 case 67:
1274 YY_RULE_SETUP
1275 #line 159 "cmDependsJavaLexer.in.l"
1276 { SYMBOL; return jp_COLON; }
1277 case 68:
1278 YY_RULE_SETUP
1279 #line 160 "cmDependsJavaLexer.in.l"
1280 { SYMBOL; return jp_COMMA; }
1281 case 69:
1282 YY_RULE_SETUP
1283 #line 161 "cmDependsJavaLexer.in.l"
1284 { SYMBOL; return jp_CURLYEND; }
1285 case 70:
1286 YY_RULE_SETUP
1287 #line 162 "cmDependsJavaLexer.in.l"
1288 { SYMBOL; return jp_CURLYSTART; }
1289 case 71:
1290 YY_RULE_SETUP
1291 #line 163 "cmDependsJavaLexer.in.l"
1292 { SYMBOL; return jp_DIVIDE; }
1293 case 72:
1294 YY_RULE_SETUP
1295 #line 164 "cmDependsJavaLexer.in.l"
1296 { SYMBOL; return jp_DIVIDEEQUALS; }
1297 case 73:
1298 YY_RULE_SETUP
1299 #line 165 "cmDependsJavaLexer.in.l"
1300 { SYMBOL; return jp_DOLLAR; }
1301 case 74:
1302 YY_RULE_SETUP
1303 #line 166 "cmDependsJavaLexer.in.l"
1304 { SYMBOL; return jp_DOT; }
1305 case 75:
1306 YY_RULE_SETUP
1307 #line 167 "cmDependsJavaLexer.in.l"
1308 { SYMBOL; return jp_EQUALS; }
1309 case 76:
1310 YY_RULE_SETUP
1311 #line 168 "cmDependsJavaLexer.in.l"
1312 { SYMBOL; return jp_EQUALSEQUALS; }
1313 case 77:
1314 YY_RULE_SETUP
1315 #line 169 "cmDependsJavaLexer.in.l"
1316 { SYMBOL; return jp_EXCLAMATION; }
1317 case 78:
1318 YY_RULE_SETUP
1319 #line 170 "cmDependsJavaLexer.in.l"
1320 { SYMBOL; return jp_EXCLAMATIONEQUALS; }
1321 case 79:
1322 YY_RULE_SETUP
1323 #line 171 "cmDependsJavaLexer.in.l"
1324 { SYMBOL; return jp_GREATER; }
1325 case 80:
1326 YY_RULE_SETUP
1327 #line 172 "cmDependsJavaLexer.in.l"
1328 { SYMBOL; return jp_GTEQUALS; }
1329 case 81:
1330 YY_RULE_SETUP
1331 #line 173 "cmDependsJavaLexer.in.l"
1332 { SYMBOL; return jp_GTGT; }
1333 case 82:
1334 YY_RULE_SETUP
1335 #line 174 "cmDependsJavaLexer.in.l"
1336 { SYMBOL; return jp_GTGTEQUALS; }
1337 case 83:
1338 YY_RULE_SETUP
1339 #line 175 "cmDependsJavaLexer.in.l"
1340 { SYMBOL; return jp_GTGTGT; }
1341 case 84:
1342 YY_RULE_SETUP
1343 #line 176 "cmDependsJavaLexer.in.l"
1344 { SYMBOL; return jp_GTGTGTEQUALS; }
1345 case 85:
1346 YY_RULE_SETUP
1347 #line 177 "cmDependsJavaLexer.in.l"
1348 { SYMBOL; return jp_LESLESEQUALS; }
1349 case 86:
1350 YY_RULE_SETUP
1351 #line 178 "cmDependsJavaLexer.in.l"
1352 { SYMBOL; return jp_LESSTHAN; }
1353 case 87:
1354 YY_RULE_SETUP
1355 #line 179 "cmDependsJavaLexer.in.l"
1356 { SYMBOL; return jp_LTEQUALS; }
1357 case 88:
1358 YY_RULE_SETUP
1359 #line 180 "cmDependsJavaLexer.in.l"
1360 { SYMBOL; return jp_LTLT; }
1361 case 89:
1362 YY_RULE_SETUP
1363 #line 181 "cmDependsJavaLexer.in.l"
1364 { SYMBOL; return jp_MINUS; }
1365 case 90:
1366 YY_RULE_SETUP
1367 #line 182 "cmDependsJavaLexer.in.l"
1368 { SYMBOL; return jp_MINUSEQUALS; }
1369 case 91:
1370 YY_RULE_SETUP
1371 #line 183 "cmDependsJavaLexer.in.l"
1372 { SYMBOL; return jp_MINUSMINUS; }
1373 case 92:
1374 YY_RULE_SETUP
1375 #line 184 "cmDependsJavaLexer.in.l"
1376 { SYMBOL; return jp_PAREEND; }
1377 case 93:
1378 YY_RULE_SETUP
1379 #line 185 "cmDependsJavaLexer.in.l"
1380 { SYMBOL; return jp_PARESTART; }
1381 case 94:
1382 YY_RULE_SETUP
1383 #line 186 "cmDependsJavaLexer.in.l"
1384 { SYMBOL; return jp_PERCENT; }
1385 case 95:
1386 YY_RULE_SETUP
1387 #line 187 "cmDependsJavaLexer.in.l"
1388 { SYMBOL; return jp_PERCENTEQUALS; }
1389 case 96:
1390 YY_RULE_SETUP
1391 #line 188 "cmDependsJavaLexer.in.l"
1392 { SYMBOL; return jp_PIPE; }
1393 case 97:
1394 YY_RULE_SETUP
1395 #line 189 "cmDependsJavaLexer.in.l"
1396 { SYMBOL; return jp_PIPEEQUALS; }
1397 case 98:
1398 YY_RULE_SETUP
1399 #line 190 "cmDependsJavaLexer.in.l"
1400 { SYMBOL; return jp_PIPEPIPE; }
1401 case 99:
1402 YY_RULE_SETUP
1403 #line 191 "cmDependsJavaLexer.in.l"
1404 { SYMBOL; return jp_PLUS; }
1405 case 100:
1406 YY_RULE_SETUP
1407 #line 192 "cmDependsJavaLexer.in.l"
1408 { SYMBOL; return jp_PLUSEQUALS; }
1409 case 101:
1410 YY_RULE_SETUP
1411 #line 193 "cmDependsJavaLexer.in.l"
1412 { SYMBOL; return jp_PLUSPLUS; }
1413 case 102:
1414 YY_RULE_SETUP
1415 #line 194 "cmDependsJavaLexer.in.l"
1416 { SYMBOL; return jp_QUESTION; }
1417 case 103:
1418 YY_RULE_SETUP
1419 #line 195 "cmDependsJavaLexer.in.l"
1420 { SYMBOL; return jp_SEMICOL; }
1421 case 104:
1422 YY_RULE_SETUP
1423 #line 196 "cmDependsJavaLexer.in.l"
1424 { SYMBOL; return jp_TILDE; }
1425 case 105:
1426 YY_RULE_SETUP
1427 #line 197 "cmDependsJavaLexer.in.l"
1428 { SYMBOL; return jp_TIMES; }
1429 case 106:
1430 YY_RULE_SETUP
1431 #line 198 "cmDependsJavaLexer.in.l"
1432 { SYMBOL; return jp_TIMESEQUALS; }
1433 case 107:
1434 YY_RULE_SETUP
1435 #line 200 "cmDependsJavaLexer.in.l"
1436 {
1437   yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
1438   return jp_NAME;
1439 }
1440 case 108:
1441 /* rule 108 can match eol */
1442 YY_RULE_SETUP
1443 #line 205 "cmDependsJavaLexer.in.l"
1444 { }
1445   YY_BREAK
1446 case 109:
1447 /* rule 109 can match eol */
1448 YY_RULE_SETUP
1449 #line 206 "cmDependsJavaLexer.in.l"
1450 { }
1451   YY_BREAK
1452 case 110:
1453 YY_RULE_SETUP
1454 #line 207 "cmDependsJavaLexer.in.l"
1455 {
1456   std::cerr << "Unknown character: " << yytext[0]
1457     << " (" << (int)yytext[0] << ")" << std::endl;
1458   yyextra->Error("Unknown character");
1459   return jp_ERROR;
1460 }
1461 case 111:
1462 YY_RULE_SETUP
1463 #line 214 "cmDependsJavaLexer.in.l"
1464 ECHO;
1465   YY_BREAK
1466 #line 1590 "cmDependsJavaLexer.cxx"
1467 case YY_STATE_EOF(INITIAL):
1468 case YY_STATE_EOF(comment):
1469 case YY_STATE_EOF(string):
1470   yyterminate();
1471
1472   case YY_END_OF_BUFFER:
1473     {
1474     /* Amount of text matched not including the EOB char. */
1475     int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1476
1477     /* Undo the effects of YY_DO_BEFORE_ACTION. */
1478     *yy_cp = yyg->yy_hold_char;
1479     YY_RESTORE_YY_MORE_OFFSET
1480
1481     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1482       {
1483       /* We're scanning a new file or input source.  It's
1484        * possible that this happened because the user
1485        * just pointed yyin at a new source and called
1486        * cmDependsJava_yylex().  If so, then we have to assure
1487        * consistency between YY_CURRENT_BUFFER and our
1488        * globals.  Here is the right place to do so, because
1489        * this is the first action (other than possibly a
1490        * back-up) that will match for the new input source.
1491        */
1492       yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1493       YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1494       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1495       }
1496
1497     /* Note that here we test for yy_c_buf_p "<=" to the position
1498      * of the first EOB in the buffer, since yy_c_buf_p will
1499      * already have been incremented past the NUL character
1500      * (since all states make transitions on EOB to the
1501      * end-of-buffer state).  Contrast this with the test
1502      * in input().
1503      */
1504     if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1505       { /* This was really a NUL. */
1506       yy_state_type yy_next_state;
1507
1508       yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1509
1510       yy_current_state = yy_get_previous_state( yyscanner );
1511
1512       /* Okay, we're now positioned to make the NUL
1513        * transition.  We couldn't have
1514        * yy_get_previous_state() go ahead and do it
1515        * for us because it doesn't know how to deal
1516        * with the possibility of jamming (and we don't
1517        * want to build jamming into it because then it
1518        * will run more slowly).
1519        */
1520
1521       yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1522
1523       yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1524
1525       if ( yy_next_state )
1526         {
1527         /* Consume the NUL. */
1528         yy_cp = ++yyg->yy_c_buf_p;
1529         yy_current_state = yy_next_state;
1530         goto yy_match;
1531         }
1532
1533       else
1534         {
1535         yy_cp = yyg->yy_c_buf_p;
1536         goto yy_find_action;
1537         }
1538       }
1539
1540     else switch ( yy_get_next_buffer( yyscanner ) )
1541       {
1542       case EOB_ACT_END_OF_FILE:
1543         {
1544         yyg->yy_did_buffer_switch_on_eof = 0;
1545
1546         if ( cmDependsJava_yywrap(yyscanner ) )
1547           {
1548           /* Note: because we've taken care in
1549            * yy_get_next_buffer() to have set up
1550            * yytext, we can now set up
1551            * yy_c_buf_p so that if some total
1552            * hoser (like flex itself) wants to
1553            * call the scanner after we return the
1554            * YY_NULL, it'll still work - another
1555            * YY_NULL will get returned.
1556            */
1557           yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1558
1559           yy_act = YY_STATE_EOF(YY_START);
1560           goto do_action;
1561           }
1562
1563         else
1564           {
1565           if ( ! yyg->yy_did_buffer_switch_on_eof )
1566             YY_NEW_FILE;
1567           }
1568         break;
1569         }
1570
1571       case EOB_ACT_CONTINUE_SCAN:
1572         yyg->yy_c_buf_p =
1573           yyg->yytext_ptr + yy_amount_of_matched_text;
1574
1575         yy_current_state = yy_get_previous_state( yyscanner );
1576
1577         yy_cp = yyg->yy_c_buf_p;
1578         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1579         goto yy_match;
1580
1581       case EOB_ACT_LAST_MATCH:
1582         yyg->yy_c_buf_p =
1583         &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1584
1585         yy_current_state = yy_get_previous_state( yyscanner );
1586
1587         yy_cp = yyg->yy_c_buf_p;
1588         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1589         goto yy_find_action;
1590       }
1591     break;
1592     }
1593
1594   default:
1595     YY_FATAL_ERROR(
1596       "fatal flex scanner internal error--no action found" );
1597   } /* end of action switch */
1598     } /* end of scanning one token */
1599 return 0; /* this should not happen but it silences a warning*/
1600 } /* end of cmDependsJava_yylex */
1601
1602 /* yy_get_next_buffer - try to read in a new buffer
1603  *
1604  * Returns a code representing an action:
1605  *  EOB_ACT_LAST_MATCH -
1606  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1607  *  EOB_ACT_END_OF_FILE - end of file
1608  */
1609 static int yy_get_next_buffer (yyscan_t yyscanner)
1610 {
1611     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1612   register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1613   register char *source = yyg->yytext_ptr;
1614   register int number_to_move, i;
1615   int ret_val;
1616
1617   if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1618     YY_FATAL_ERROR(
1619     "fatal flex scanner internal error--end of buffer missed" );
1620
1621   if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1622     { /* Don't try to fill the buffer, so this is an EOF. */
1623     if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1624       {
1625       /* We matched a single character, the EOB, so
1626        * treat this as a final EOF.
1627        */
1628       return EOB_ACT_END_OF_FILE;
1629       }
1630
1631     else
1632       {
1633       /* We matched some text prior to the EOB, first
1634        * process it.
1635        */
1636       return EOB_ACT_LAST_MATCH;
1637       }
1638     }
1639
1640   /* Try to read more data. */
1641
1642   /* First move last chars to start of buffer. */
1643   number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1644
1645   for ( i = 0; i < number_to_move; ++i )
1646     *(dest++) = *(source++);
1647
1648   if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1649     /* don't do the read, it's not guaranteed to return an EOF,
1650      * just force an EOF
1651      */
1652     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1653
1654   else
1655     {
1656       size_t nuto_read =
1657       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1658
1659     while ( nuto_read <= 0 )
1660       { /* Not enough room in the buffer - grow it. */
1661
1662       /* just a shorter name for the current buffer */
1663       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1664
1665       int yy_c_buf_p_offset =
1666         (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1667
1668       if ( b->yy_is_our_buffer )
1669         {
1670         int new_size = b->yy_buf_size * 2;
1671
1672         if ( new_size <= 0 )
1673           b->yy_buf_size += b->yy_buf_size / 8;
1674         else
1675           b->yy_buf_size *= 2;
1676
1677         b->yy_ch_buf = (char *)
1678           /* Include room in for 2 EOB chars. */
1679           cmDependsJava_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1680         }
1681       else
1682         /* Can't grow it, we don't own it. */
1683         b->yy_ch_buf = 0;
1684
1685       if ( ! b->yy_ch_buf )
1686         YY_FATAL_ERROR(
1687         "fatal error - scanner input buffer overflow" );
1688
1689       yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1690
1691       nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1692             number_to_move - 1;
1693
1694       }
1695
1696     if ( nuto_read > YY_READ_BUF_SIZE )
1697       nuto_read = YY_READ_BUF_SIZE;
1698
1699     /* Read in more data. */
1700     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1701       yyg->yy_n_chars, nuto_read );
1702
1703     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1704     }
1705
1706   if ( yyg->yy_n_chars == 0 )
1707     {
1708     if ( number_to_move == YY_MORE_ADJ )
1709       {
1710       ret_val = EOB_ACT_END_OF_FILE;
1711       cmDependsJava_yyrestart(yyin  ,yyscanner);
1712       }
1713
1714     else
1715       {
1716       ret_val = EOB_ACT_LAST_MATCH;
1717       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1718         YY_BUFFER_EOF_PENDING;
1719       }
1720     }
1721
1722   else
1723     ret_val = EOB_ACT_CONTINUE_SCAN;
1724
1725   yyg->yy_n_chars += number_to_move;
1726   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1727   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1728
1729   yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1730
1731   return ret_val;
1732 }
1733
1734 /* yy_get_previous_state - get the state just before the EOB char was reached */
1735
1736     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1737 {
1738   register yy_state_type yy_current_state;
1739   register char *yy_cp;
1740     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1741
1742   yy_current_state = yyg->yy_start;
1743
1744   for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1745     {
1746     register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1747     if ( yy_accept[yy_current_state] )
1748       {
1749       yyg->yy_last_accepting_state = yy_current_state;
1750       yyg->yy_last_accepting_cpos = yy_cp;
1751       }
1752     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1753       {
1754       yy_current_state = (int) yy_def[yy_current_state];
1755       if ( yy_current_state >= 327 )
1756         yy_c = yy_meta[(unsigned int) yy_c];
1757       }
1758     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1759     }
1760
1761   return yy_current_state;
1762 }
1763
1764 /* yy_try_NUL_trans - try to make a transition on the NUL character
1765  *
1766  * synopsis
1767  *  next_state = yy_try_NUL_trans( current_state );
1768  */
1769     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
1770 {
1771   register int yy_is_jam;
1772     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1773   register char *yy_cp = yyg->yy_c_buf_p;
1774
1775   register YY_CHAR yy_c = 1;
1776   if ( yy_accept[yy_current_state] )
1777     {
1778     yyg->yy_last_accepting_state = yy_current_state;
1779     yyg->yy_last_accepting_cpos = yy_cp;
1780     }
1781   while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1782     {
1783     yy_current_state = (int) yy_def[yy_current_state];
1784     if ( yy_current_state >= 327 )
1785       yy_c = yy_meta[(unsigned int) yy_c];
1786     }
1787   yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1788   yy_is_jam = (yy_current_state == 326);
1789
1790   return yy_is_jam ? 0 : yy_current_state;
1791 }
1792
1793 #ifndef YY_NO_INPUT
1794 #ifdef __cplusplus
1795     static int yyinput (yyscan_t yyscanner)
1796 #else
1797     static int input  (yyscan_t yyscanner)
1798 #endif
1799
1800 {
1801   int c;
1802     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1803
1804   *yyg->yy_c_buf_p = yyg->yy_hold_char;
1805
1806   if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1807     {
1808     /* yy_c_buf_p now points to the character we want to return.
1809      * If this occurs *before* the EOB characters, then it's a
1810      * valid NUL; if not, then we've hit the end of the buffer.
1811      */
1812     if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1813       /* This was really a NUL. */
1814       *yyg->yy_c_buf_p = '\0';
1815
1816     else
1817       { /* need more input */
1818       int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1819       ++yyg->yy_c_buf_p;
1820
1821       switch ( yy_get_next_buffer( yyscanner ) )
1822         {
1823         case EOB_ACT_LAST_MATCH:
1824           /* This happens because yy_g_n_b()
1825            * sees that we've accumulated a
1826            * token and flags that we need to
1827            * try matching the token before
1828            * proceeding.  But for input(),
1829            * there's no matching to consider.
1830            * So convert the EOB_ACT_LAST_MATCH
1831            * to EOB_ACT_END_OF_FILE.
1832            */
1833
1834           /* Reset buffer status. */
1835           cmDependsJava_yyrestart(yyin ,yyscanner);
1836
1837           /*FALLTHROUGH*/
1838
1839         case EOB_ACT_END_OF_FILE:
1840           {
1841           if ( cmDependsJava_yywrap(yyscanner ) )
1842             return EOF;
1843
1844           if ( ! yyg->yy_did_buffer_switch_on_eof )
1845             YY_NEW_FILE;
1846 #ifdef __cplusplus
1847           return yyinput(yyscanner);
1848 #else
1849           return input(yyscanner);
1850 #endif
1851           }
1852
1853         case EOB_ACT_CONTINUE_SCAN:
1854           yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1855           break;
1856         }
1857       }
1858     }
1859
1860   c = *(unsigned char *) yyg->yy_c_buf_p;  /* cast for 8-bit char's */
1861   *yyg->yy_c_buf_p = '\0';  /* preserve yytext */
1862   yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1863
1864   return c;
1865 }
1866 #endif  /* ifndef YY_NO_INPUT */
1867
1868 /** Immediately switch to a different input stream.
1869  * @param input_file A readable stream.
1870  * @param yyscanner The scanner object.
1871  * @note This function does not reset the start condition to @c INITIAL .
1872  */
1873     void cmDependsJava_yyrestart  (FILE * input_file , yyscan_t yyscanner)
1874 {
1875     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1876
1877   if ( ! YY_CURRENT_BUFFER ){
1878         cmDependsJava_yyensure_buffer_stack (yyscanner);
1879     YY_CURRENT_BUFFER_LVALUE =
1880             cmDependsJava_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1881   }
1882
1883   cmDependsJava_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1884   cmDependsJava_yy_load_buffer_state(yyscanner );
1885 }
1886
1887 /** Switch to a different input buffer.
1888  * @param new_buffer The new input buffer.
1889  * @param yyscanner The scanner object.
1890  */
1891     void cmDependsJava_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
1892 {
1893     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1894
1895   /* TODO. We should be able to replace this entire function body
1896    * with
1897    *    cmDependsJava_yypop_buffer_state();
1898    *    cmDependsJava_yypush_buffer_state(new_buffer);
1899      */
1900   cmDependsJava_yyensure_buffer_stack (yyscanner);
1901   if ( YY_CURRENT_BUFFER == new_buffer )
1902     return;
1903
1904   if ( YY_CURRENT_BUFFER )
1905     {
1906     /* Flush out information for old buffer. */
1907     *yyg->yy_c_buf_p = yyg->yy_hold_char;
1908     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1909     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1910     }
1911
1912   YY_CURRENT_BUFFER_LVALUE = new_buffer;
1913   cmDependsJava_yy_load_buffer_state(yyscanner );
1914
1915   /* We don't actually know whether we did this switch during
1916    * EOF (cmDependsJava_yywrap()) processing, but the only time this flag
1917    * is looked at is after cmDependsJava_yywrap() is called, so it's safe
1918    * to go ahead and always set it.
1919    */
1920   yyg->yy_did_buffer_switch_on_eof = 1;
1921 }
1922
1923 static void cmDependsJava_yy_load_buffer_state  (yyscan_t yyscanner)
1924 {
1925     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1926   yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1927   yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1928   yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1929   yyg->yy_hold_char = *yyg->yy_c_buf_p;
1930 }
1931
1932 /** Allocate and initialize an input buffer state.
1933  * @param file A readable stream.
1934  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1935  * @param yyscanner The scanner object.
1936  * @return the allocated buffer state.
1937  */
1938     YY_BUFFER_STATE cmDependsJava_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
1939 {
1940   YY_BUFFER_STATE b;
1941
1942   b = (YY_BUFFER_STATE) cmDependsJava_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1943   if ( ! b )
1944     YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_create_buffer()" );
1945
1946   b->yy_buf_size = size;
1947
1948   /* yy_ch_buf has to be 2 characters longer than the size given because
1949    * we need to put in 2 end-of-buffer characters.
1950    */
1951   b->yy_ch_buf = (char *) cmDependsJava_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1952   if ( ! b->yy_ch_buf )
1953     YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_create_buffer()" );
1954
1955   b->yy_is_our_buffer = 1;
1956
1957   cmDependsJava_yy_init_buffer(b,file ,yyscanner);
1958
1959   return b;
1960 }
1961
1962 /** Destroy the buffer.
1963  * @param b a buffer created with cmDependsJava_yy_create_buffer()
1964  * @param yyscanner The scanner object.
1965  */
1966     void cmDependsJava_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1967 {
1968     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1969
1970   if ( ! b )
1971     return;
1972
1973   if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1974     YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1975
1976   if ( b->yy_is_our_buffer )
1977     cmDependsJava_yyfree((void *) b->yy_ch_buf ,yyscanner );
1978
1979   cmDependsJava_yyfree((void *) b ,yyscanner );
1980 }
1981
1982 #ifndef __cplusplus
1983 extern int isatty (int );
1984 #endif /* __cplusplus */
1985
1986 /* Initializes or reinitializes a buffer.
1987  * This function is sometimes called more than once on the same buffer,
1988  * such as during a cmDependsJava_yyrestart() or at EOF.
1989  */
1990     static void cmDependsJava_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
1991
1992 {
1993   int oerrno = errno;
1994     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1995
1996   cmDependsJava_yy_flush_buffer(b ,yyscanner);
1997
1998   b->yy_input_file = file;
1999   b->yy_fill_buffer = 1;
2000
2001     /* If b is the current buffer, then cmDependsJava_yy_init_buffer was _probably_
2002      * called from cmDependsJava_yyrestart() or through yy_get_next_buffer.
2003      * In that case, we don't want to reset the lineno or column.
2004      */
2005     if (b != YY_CURRENT_BUFFER){
2006         b->yy_bs_lineno = 1;
2007         b->yy_bs_column = 0;
2008     }
2009
2010         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2011
2012   errno = oerrno;
2013 }
2014
2015 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2016  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2017  * @param yyscanner The scanner object.
2018  */
2019     void cmDependsJava_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2020 {
2021     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2022   if ( ! b )
2023     return;
2024
2025   b->yy_n_chars = 0;
2026
2027   /* We always need two end-of-buffer characters.  The first causes
2028    * a transition to the end-of-buffer state.  The second causes
2029    * a jam in that state.
2030    */
2031   b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2032   b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2033
2034   b->yy_buf_pos = &b->yy_ch_buf[0];
2035
2036   b->yy_at_bol = 1;
2037   b->yy_buffer_status = YY_BUFFER_NEW;
2038
2039   if ( b == YY_CURRENT_BUFFER )
2040     cmDependsJava_yy_load_buffer_state(yyscanner );
2041 }
2042
2043 /** Pushes the new state onto the stack. The new state becomes
2044  *  the current state. This function will allocate the stack
2045  *  if necessary.
2046  *  @param new_buffer The new state.
2047  *  @param yyscanner The scanner object.
2048  */
2049 void cmDependsJava_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2050 {
2051     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2052   if (new_buffer == NULL)
2053     return;
2054
2055   cmDependsJava_yyensure_buffer_stack(yyscanner);
2056
2057   /* This block is copied from cmDependsJava_yy_switch_to_buffer. */
2058   if ( YY_CURRENT_BUFFER )
2059     {
2060     /* Flush out information for old buffer. */
2061     *yyg->yy_c_buf_p = yyg->yy_hold_char;
2062     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2063     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2064     }
2065
2066   /* Only push if top exists. Otherwise, replace top. */
2067   if (YY_CURRENT_BUFFER)
2068     yyg->yy_buffer_stack_top++;
2069   YY_CURRENT_BUFFER_LVALUE = new_buffer;
2070
2071   /* copied from cmDependsJava_yy_switch_to_buffer. */
2072   cmDependsJava_yy_load_buffer_state(yyscanner );
2073   yyg->yy_did_buffer_switch_on_eof = 1;
2074 }
2075
2076 /** Removes and deletes the top of the stack, if present.
2077  *  The next element becomes the new top.
2078  *  @param yyscanner The scanner object.
2079  */
2080 void cmDependsJava_yypop_buffer_state (yyscan_t yyscanner)
2081 {
2082     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2083   if (!YY_CURRENT_BUFFER)
2084     return;
2085
2086   cmDependsJava_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2087   YY_CURRENT_BUFFER_LVALUE = NULL;
2088   if (yyg->yy_buffer_stack_top > 0)
2089     --yyg->yy_buffer_stack_top;
2090
2091   if (YY_CURRENT_BUFFER) {
2092     cmDependsJava_yy_load_buffer_state(yyscanner );
2093     yyg->yy_did_buffer_switch_on_eof = 1;
2094   }
2095 }
2096
2097 /* Allocates the stack if it does not exist.
2098  *  Guarantees space for at least one push.
2099  */
2100 static void cmDependsJava_yyensure_buffer_stack (yyscan_t yyscanner)
2101 {
2102   int nuto_alloc;
2103     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2104
2105   if (!yyg->yy_buffer_stack) {
2106
2107     /* First allocation is just for 2 elements, since we don't know if this
2108      * scanner will even need a stack. We use 2 instead of 1 to avoid an
2109      * immediate realloc on the next call.
2110          */
2111     nuto_alloc = 1;
2112     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsJava_yyalloc
2113                 (nuto_alloc * sizeof(struct yy_buffer_state*)
2114                 , yyscanner);
2115
2116     memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
2117
2118     yyg->yy_buffer_stack_max = nuto_alloc;
2119     yyg->yy_buffer_stack_top = 0;
2120     return;
2121   }
2122
2123   if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2124
2125     /* Increase the buffer to prepare for a possible push. */
2126     int grow_size = 8 /* arbitrary grow size */;
2127
2128     nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
2129     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsJava_yyrealloc
2130                 (yyg->yy_buffer_stack,
2131                 nuto_alloc * sizeof(struct yy_buffer_state*)
2132                 , yyscanner);
2133
2134     /* zero only the new slots.*/
2135     memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2136     yyg->yy_buffer_stack_max = nuto_alloc;
2137   }
2138 }
2139
2140 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2141  * @param base the character buffer
2142  * @param size the size in bytes of the character buffer
2143  * @param yyscanner The scanner object.
2144  * @return the newly allocated buffer state object.
2145  */
2146 YY_BUFFER_STATE cmDependsJava_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
2147 {
2148   YY_BUFFER_STATE b;
2149
2150   if ( size < 2 ||
2151        base[size-2] != YY_END_OF_BUFFER_CHAR ||
2152        base[size-1] != YY_END_OF_BUFFER_CHAR )
2153     /* They forgot to leave room for the EOB's. */
2154     return 0;
2155
2156   b = (YY_BUFFER_STATE) cmDependsJava_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2157   if ( ! b )
2158     YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_scan_buffer()" );
2159
2160   b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
2161   b->yy_buf_pos = b->yy_ch_buf = base;
2162   b->yy_is_our_buffer = 0;
2163   b->yy_input_file = 0;
2164   b->yy_n_chars = b->yy_buf_size;
2165   b->yy_is_interactive = 0;
2166   b->yy_at_bol = 1;
2167   b->yy_fill_buffer = 0;
2168   b->yy_buffer_status = YY_BUFFER_NEW;
2169
2170   cmDependsJava_yy_switch_to_buffer(b ,yyscanner );
2171
2172   return b;
2173 }
2174
2175 /** Setup the input buffer state to scan a string. The next call to cmDependsJava_yylex() will
2176  * scan from a @e copy of @a str.
2177  * @param str a NUL-terminated string to scan
2178  * @param yyscanner The scanner object.
2179  * @return the newly allocated buffer state object.
2180  * @note If you want to scan bytes that may contain NUL values, then use
2181  *       cmDependsJava_yy_scan_bytes() instead.
2182  */
2183 YY_BUFFER_STATE cmDependsJava_yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
2184 {
2185
2186   return cmDependsJava_yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
2187 }
2188
2189 /** Setup the input buffer state to scan the given bytes. The next call to cmDependsJava_yylex() will
2190  * scan from a @e copy of @a bytes.
2191  * @param bytes the byte buffer to scan
2192  * @param len the number of bytes in the buffer pointed to by @a bytes.
2193  * @param yyscanner The scanner object.
2194  * @return the newly allocated buffer state object.
2195  */
2196 YY_BUFFER_STATE cmDependsJava_yy_scan_bytes  (yyconst char * bytes, int  len , yyscan_t yyscanner)
2197 {
2198   YY_BUFFER_STATE b;
2199   char *buf;
2200   yy_size_t n;
2201   int i;
2202
2203   /* Get memory for full buffer, including space for trailing EOB's. */
2204   n = len + 2;
2205   buf = (char *) cmDependsJava_yyalloc(n ,yyscanner );
2206   if ( ! buf )
2207     YY_FATAL_ERROR( "out of dynamic memory in cmDependsJava_yy_scan_bytes()" );
2208
2209   for ( i = 0; i < len; ++i )
2210     buf[i] = bytes[i];
2211
2212   buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2213
2214   b = cmDependsJava_yy_scan_buffer(buf,n ,yyscanner);
2215   if ( ! b )
2216     YY_FATAL_ERROR( "bad buffer in cmDependsJava_yy_scan_bytes()" );
2217
2218   /* It's okay to grow etc. this buffer, and we should throw it
2219    * away when we're done.
2220    */
2221   b->yy_is_our_buffer = 1;
2222
2223   return b;
2224 }
2225
2226 #ifndef YY_EXIT_FAILURE
2227 #define YY_EXIT_FAILURE 2
2228 #endif
2229
2230 static void yy_fatal_error (yyconst char* msg , yyscan_t)
2231 {
2232       (void) fprintf( stderr, "%s\n", msg );
2233   exit( YY_EXIT_FAILURE );
2234 }
2235
2236 /* Redefine yyless() so it works in section 3 code. */
2237
2238 #undef yyless
2239 #define yyless(n) \
2240   do \
2241     { \
2242     /* Undo effects of setting up yytext. */ \
2243         int yyless_macro_arg = (n); \
2244         YY_LESS_LINENO(yyless_macro_arg);\
2245     yytext[yyleng] = yyg->yy_hold_char; \
2246     yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2247     yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2248     *yyg->yy_c_buf_p = '\0'; \
2249     yyleng = yyless_macro_arg; \
2250     } \
2251   while ( 0 )
2252
2253 /* Accessor  methods (get/set functions) to struct members. */
2254
2255 /** Get the user-defined data for this scanner.
2256  * @param yyscanner The scanner object.
2257  */
2258 YY_EXTRA_TYPE cmDependsJava_yyget_extra  (yyscan_t yyscanner)
2259 {
2260     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2261     return yyextra;
2262 }
2263
2264 /** Get the current line number.
2265  * @param yyscanner The scanner object.
2266  */
2267 int cmDependsJava_yyget_lineno  (yyscan_t yyscanner)
2268 {
2269     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2270
2271         if (! YY_CURRENT_BUFFER)
2272             return 0;
2273
2274     return yylineno;
2275 }
2276
2277 /** Get the current column number.
2278  * @param yyscanner The scanner object.
2279  */
2280 int cmDependsJava_yyget_column  (yyscan_t yyscanner)
2281 {
2282     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2283
2284         if (! YY_CURRENT_BUFFER)
2285             return 0;
2286
2287     return yycolumn;
2288 }
2289
2290 /** Get the input stream.
2291  * @param yyscanner The scanner object.
2292  */
2293 FILE *cmDependsJava_yyget_in  (yyscan_t yyscanner)
2294 {
2295     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2296     return yyin;
2297 }
2298
2299 /** Get the output stream.
2300  * @param yyscanner The scanner object.
2301  */
2302 FILE *cmDependsJava_yyget_out  (yyscan_t yyscanner)
2303 {
2304     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2305     return yyout;
2306 }
2307
2308 /** Get the length of the current token.
2309  * @param yyscanner The scanner object.
2310  */
2311 int cmDependsJava_yyget_leng  (yyscan_t yyscanner)
2312 {
2313     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2314     return yyleng;
2315 }
2316
2317 /** Get the current token.
2318  * @param yyscanner The scanner object.
2319  */
2320
2321 char *cmDependsJava_yyget_text  (yyscan_t yyscanner)
2322 {
2323     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2324     return yytext;
2325 }
2326
2327 /** Set the user-defined data. This data is never touched by the scanner.
2328  * @param user_defined The data to be associated with this scanner.
2329  * @param yyscanner The scanner object.
2330  */
2331 void cmDependsJava_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2332 {
2333     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2334     yyextra = user_defined ;
2335 }
2336
2337 /** Set the current line number.
2338  * @param line_number
2339  * @param yyscanner The scanner object.
2340  */
2341 void cmDependsJava_yyset_lineno (int  line_number , yyscan_t yyscanner)
2342 {
2343     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2344
2345         /* lineno is only valid if an input buffer exists. */
2346         if (! YY_CURRENT_BUFFER )
2347            yy_fatal_error( "cmDependsJava_yyset_lineno called with no buffer" , yyscanner);
2348
2349     yylineno = line_number;
2350 }
2351
2352 /** Set the current column.
2353  * @param line_number
2354  * @param yyscanner The scanner object.
2355  */
2356 void cmDependsJava_yyset_column (int  column_no , yyscan_t yyscanner)
2357 {
2358     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2359
2360         /* column is only valid if an input buffer exists. */
2361         if (! YY_CURRENT_BUFFER )
2362            yy_fatal_error( "cmDependsJava_yyset_column called with no buffer" , yyscanner);
2363
2364     yycolumn = column_no;
2365 }
2366
2367 /** Set the input stream. This does not discard the current
2368  * input buffer.
2369  * @param in_str A readable stream.
2370  * @param yyscanner The scanner object.
2371  * @see cmDependsJava_yy_switch_to_buffer
2372  */
2373 void cmDependsJava_yyset_in (FILE *  in_str , yyscan_t yyscanner)
2374 {
2375     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2376     yyin = in_str ;
2377 }
2378
2379 void cmDependsJava_yyset_out (FILE *  out_str , yyscan_t yyscanner)
2380 {
2381     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2382     yyout = out_str ;
2383 }
2384
2385 int cmDependsJava_yyget_debug  (yyscan_t yyscanner)
2386 {
2387     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2388     return yy_flex_debug;
2389 }
2390
2391 void cmDependsJava_yyset_debug (int  bdebug , yyscan_t yyscanner)
2392 {
2393     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2394     yy_flex_debug = bdebug ;
2395 }
2396
2397 /* Accessor methods for yylval and yylloc */
2398
2399 static int yy_init_globals (yyscan_t yyscanner)
2400 {
2401     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2402     /* Initialization is the same as for the non-reentrant scanner.
2403        This function is called once per scanner lifetime. */
2404
2405     yyg->yy_buffer_stack = 0;
2406     yyg->yy_buffer_stack_top = 0;
2407     yyg->yy_buffer_stack_max = 0;
2408     yyg->yy_c_buf_p = (char *) 0;
2409     yyg->yy_init = 1;
2410     yyg->yy_start = 0;
2411     yyg->yy_start_stack_ptr = 0;
2412     yyg->yy_start_stack_depth = 0;
2413     yyg->yy_start_stack = (int *) 0;
2414
2415 /* Defined in main.c */
2416 #ifdef YY_STDINIT
2417     yyin = stdin;
2418     yyout = stdout;
2419 #else
2420     yyin = (FILE *) 0;
2421     yyout = (FILE *) 0;
2422 #endif
2423
2424     /* For future reference: Set errno on error, since we are called by
2425      * cmDependsJava_yylex_init()
2426      */
2427     return 0;
2428 }
2429
2430 /* User-visible API */
2431
2432 /* cmDependsJava_yylex_init is special because it creates the scanner itself, so it is
2433  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2434  * That's why we explicitly handle the declaration, instead of using our macros.
2435  */
2436
2437 int cmDependsJava_yylex_init(yyscan_t* ptr_yy_globals)
2438
2439 {
2440     if (ptr_yy_globals == NULL){
2441         errno = EINVAL;
2442         return 1;
2443     }
2444
2445     *ptr_yy_globals = (yyscan_t) cmDependsJava_yyalloc ( sizeof( struct yyguts_t ), NULL );
2446
2447     if (*ptr_yy_globals == NULL){
2448         errno = ENOMEM;
2449         return 1;
2450     }
2451
2452     memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2453
2454     return yy_init_globals ( *ptr_yy_globals );
2455 }
2456
2457 /* cmDependsJava_yylex_destroy is for both reentrant and non-reentrant scanners. */
2458 int cmDependsJava_yylex_destroy  (yyscan_t yyscanner)
2459 {
2460     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2461
2462     /* Pop the buffer stack, destroying each element. */
2463   while(YY_CURRENT_BUFFER){
2464     cmDependsJava_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2465     YY_CURRENT_BUFFER_LVALUE = NULL;
2466     cmDependsJava_yypop_buffer_state(yyscanner);
2467   }
2468
2469   /* Destroy the stack itself. */
2470   cmDependsJava_yyfree(yyg->yy_buffer_stack ,yyscanner);
2471   yyg->yy_buffer_stack = NULL;
2472
2473     /* Destroy the start condition stack. */
2474         cmDependsJava_yyfree(yyg->yy_start_stack ,yyscanner );
2475         yyg->yy_start_stack = NULL;
2476
2477     /* Destroy the main struct (reentrant only). */
2478     cmDependsJava_yyfree ( yyscanner , yyscanner );
2479     return 0;
2480 }
2481
2482 /*
2483  * Internal utility routines.
2484  */
2485
2486 #ifndef yytext_ptr
2487 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2488 {
2489   register int i;
2490     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2491   for ( i = 0; i < n; ++i )
2492     s1[i] = s2[i];
2493 }
2494 #endif
2495
2496 #ifdef YY_NEED_STRLEN
2497 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2498 {
2499   register int n;
2500     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2501   for ( n = 0; s[n]; ++n )
2502     ;
2503
2504   return n;
2505 }
2506 #endif
2507
2508 void *cmDependsJava_yyalloc (yy_size_t  size , yyscan_t)
2509 {
2510   return (void *) malloc( size );
2511 }
2512
2513 void *cmDependsJava_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t)
2514 {
2515   /* The cast to (char *) in the following accommodates both
2516    * implementations that use char* generic pointers, and those
2517    * that use void* generic pointers.  It works with the latter
2518    * because both ANSI C and C++ allow castless assignment from
2519    * any pointer type to void*, and deal with argument conversions
2520    * as though doing an assignment.
2521    */
2522   return (void *) realloc( (char *) ptr, size );
2523 }
2524
2525 void cmDependsJava_yyfree (void * ptr , yyscan_t)
2526 {
2527   free( (char *) ptr );  /* see cmDependsJava_yyrealloc() for (char *) cast */
2528 }
2529
2530 #define YYTABLES_NAME "yytables"
2531
2532 #undef YY_NEW_FILE
2533 #undef YY_FLUSH_BUFFER
2534 #undef yy_set_bol
2535 #undef yy_new_buffer
2536 #undef yy_set_interactive
2537 #undef yytext_ptr
2538 #undef YY_DO_BEFORE_ACTION
2539
2540 #ifdef YY_DECL_IS_OURS
2541 #undef YY_DECL_IS_OURS
2542 #undef YY_DECL
2543 #endif
2544 #line 214 "cmDependsJavaLexer.in.l"
2545
2546
2547