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