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