Source/cmDependsFortranLexer.cxx

   1 /*============================================================================
   2   CMake - Cross Platform Makefile Generator
   3   Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
   4
   5   Distributed under the OSI-approved BSD License (the "License");
   6   see accompanying file Copyright.txt for details.
   7
   8   This software is distributed WITHOUT ANY WARRANTY; without even the
   9   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10   See the License for more information.
  11 ============================================================================*/
  12 #line 2 "cmDependsFortranLexer.cxx"
  13
  14 #line 4 "cmDependsFortranLexer.cxx"
  15
  16 #define  YY_INT_ALIGNED short int
  17
  18 /* A lexical scanner generated by flex */
  19
  20 #define FLEX_SCANNER
  21 #define YY_FLEX_MAJOR_VERSION 2
  22 #define YY_FLEX_MINOR_VERSION 5
  23 #define YY_FLEX_SUBMINOR_VERSION 35
  24 #if YY_FLEX_SUBMINOR_VERSION > 0
  25 #define FLEX_BETA
  26 #endif
  27
  28 /* First, we deal with  platform-specific or compiler-specific issues. */
  29
  30 /* begin standard C headers. */
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <stdlib.h>
  35
  36 /* end standard C headers. */
  37
  38 /* flex integer type definitions */
  39
  40 #ifndef FLEXINT_H
  41 #define FLEXINT_H
  42
  43 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  44
  45 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  46
  47 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  48  * if you want the limit (max/min) macros for int types.
  49  */
  50 #ifndef __STDC_LIMIT_MACROS
  51 #define __STDC_LIMIT_MACROS 1
  52 #endif
  53
  54 #include <inttypes.h>
  55 typedef int8_t flex_int8_t;
  56 typedef uint8_t flex_uint8_t;
  57 typedef int16_t flex_int16_t;
  58 typedef uint16_t flex_uint16_t;
  59 typedef int32_t flex_int32_t;
  60 typedef uint32_t flex_uint32_t;
  61 #else
  62 typedef signed char flex_int8_t;
  63 typedef short int flex_int16_t;
  64 typedef int flex_int32_t;
  65 typedef unsigned char flex_uint8_t;
  66 typedef unsigned short int flex_uint16_t;
  67 typedef unsigned int flex_uint32_t;
  68
  69 /* Limits of integral types. */
  70 #ifndef INT8_MIN
  71 #define INT8_MIN               (-128)
  72 #endif
  73 #ifndef INT16_MIN
  74 #define INT16_MIN              (-32767-1)
  75 #endif
  76 #ifndef INT32_MIN
  77 #define INT32_MIN              (-2147483647-1)
  78 #endif
  79 #ifndef INT8_MAX
  80 #define INT8_MAX               (127)
  81 #endif
  82 #ifndef INT16_MAX
  83 #define INT16_MAX              (32767)
  84 #endif
  85 #ifndef INT32_MAX
  86 #define INT32_MAX              (2147483647)
  87 #endif
  88 #ifndef UINT8_MAX
  89 #define UINT8_MAX              (255U)
  90 #endif
  91 #ifndef UINT16_MAX
  92 #define UINT16_MAX             (65535U)
  93 #endif
  94 #ifndef UINT32_MAX
  95 #define UINT32_MAX             (4294967295U)
  96 #endif
  97
  98 #endif /* ! C99 */
  99
 100 #endif /* ! FLEXINT_H */
 101
 102 #ifdef __cplusplus
 103
 104 /* The "const" storage-class-modifier is valid. */
 105 #define YY_USE_CONST
 106
 107 #else   /* ! __cplusplus */
 108
 109 /* C99 requires __STDC__ to be defined as 1. */
 110 #if defined (__STDC__)
 111
 112 #define YY_USE_CONST
 113
 114 #endif  /* defined (__STDC__) */
 115 #endif  /* ! __cplusplus */
 116
 117 #ifdef YY_USE_CONST
 118 #define yyconst const
 119 #else
 120 #define yyconst
 121 #endif
 122
 123 /* Returned upon end-of-file. */
 124 #define YY_NULL 0
 125
 126 /* Promotes a possibly negative, possibly signed char to an unsigned
 127  * integer for use as an array index.  If the signed char is negative,
 128  * we want to instead treat it as an 8-bit unsigned char, hence the
 129  * double cast.
 130  */
 131 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 132
 133 /* An opaque pointer. */
 134 #ifndef YY_TYPEDEF_YY_SCANNER_T
 135 #define YY_TYPEDEF_YY_SCANNER_T
 136 typedef void* yyscan_t;
 137 #endif
 138
 139 /* For convenience, these vars (plus the bison vars far below)
 140    are macros in the reentrant scanner. */
 141 #define yyin yyg->yyin_r
 142 #define yyout yyg->yyout_r
 143 #define yyextra yyg->yyextra_r
 144 #define yyleng yyg->yyleng_r
 145 #define yytext yyg->yytext_r
 146 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
 147 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
 148 #define yy_flex_debug yyg->yy_flex_debug_r
 149
 150 /* Enter a start condition.  This macro really ought to take a parameter,
 151  * but we do it the disgusting crufty way forced on us by the ()-less
 152  * definition of BEGIN.
 153  */
 154 #define BEGIN yyg->yy_start = 1 + 2 *
 155
 156 /* Translate the current start state into a value that can be later handed
 157  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 158  * compatibility.
 159  */
 160 #define YY_START ((yyg->yy_start - 1) / 2)
 161 #define YYSTATE YY_START
 162
 163 /* Action number for EOF rule of a given start state. */
 164 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 165
 166 /* Special action meaning "start processing a new file". */
 167 #define YY_NEW_FILE cmDependsFortran_yyrestart(yyin ,yyscanner )
 168
 169 #define YY_END_OF_BUFFER_CHAR 0
 170
 171 /* Size of default input buffer. */
 172 #ifndef YY_BUF_SIZE
 173 #ifdef __ia64__
 174 /* On IA-64, the buffer size is 16k, not 8k.
 175  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 176  * Ditto for the __ia64__ case accordingly.
 177  */
 178 #define YY_BUF_SIZE 32768
 179 #else
 180 #define YY_BUF_SIZE 16384
 181 #endif /* __ia64__ */
 182 #endif
 183
 184 /* The state buf must be large enough to hold one state per character in the main buffer.
 185  */
 186 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 187
 188 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 189 #define YY_TYPEDEF_YY_BUFFER_STATE
 190 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 191 #endif
 192
 193 #define EOB_ACT_CONTINUE_SCAN 0
 194 #define EOB_ACT_END_OF_FILE 1
 195 #define EOB_ACT_LAST_MATCH 2
 196
 197     #define YY_LESS_LINENO(n)
 198
 199 /* Return all but the first "n" matched characters back to the input stream. */
 200 #define yyless(n) \
 201         do \
 202                 { \
 203                 /* Undo effects of setting up yytext. */ \
 204         int yyless_macro_arg = (n); \
 205         YY_LESS_LINENO(yyless_macro_arg);\
 206                 *yy_cp = yyg->yy_hold_char; \
 207                 YY_RESTORE_YY_MORE_OFFSET \
 208                 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 209                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 210                 } \
 211         while ( 0 )
 212
 213 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 214
 215 #ifndef YY_TYPEDEF_YY_SIZE_T
 216 #define YY_TYPEDEF_YY_SIZE_T
 217 typedef size_t yy_size_t;
 218 #endif
 219
 220 #ifndef YY_STRUCT_YY_BUFFER_STATE
 221 #define YY_STRUCT_YY_BUFFER_STATE
 222 struct yy_buffer_state
 223         {
 224         FILE *yy_input_file;
 225
 226         char *yy_ch_buf;                /* input buffer */
 227         char *yy_buf_pos;               /* current position in input buffer */
 228
 229         /* Size of input buffer in bytes, not including room for EOB
 230          * characters.
 231          */
 232         yy_size_t yy_buf_size;
 233
 234         /* Number of characters read into yy_ch_buf, not including EOB
 235          * characters.
 236          */
 237         int yy_n_chars;
 238
 239         /* Whether we "own" the buffer - i.e., we know we created it,
 240          * and can realloc() it to grow it, and should free() it to
 241          * delete it.
 242          */
 243         int yy_is_our_buffer;
 244
 245         /* Whether this is an "interactive" input source; if so, and
 246          * if we're using stdio for input, then we want to use getc()
 247          * instead of fread(), to make sure we stop fetching input after
 248          * each newline.
 249          */
 250         int yy_is_interactive;
 251
 252         /* Whether we're considered to be at the beginning of a line.
 253          * If so, '^' rules will be active on the next match, otherwise
 254          * not.
 255          */
 256         int yy_at_bol;
 257
 258     int yy_bs_lineno; /**< The line count. */
 259     int yy_bs_column; /**< The column count. */
 260
 261         /* Whether to try to fill the input buffer when we reach the
 262          * end of it.
 263          */
 264         int yy_fill_buffer;
 265
 266         int yy_buffer_status;
 267
 268 #define YY_BUFFER_NEW 0
 269 #define YY_BUFFER_NORMAL 1
 270         /* When an EOF's been seen but there's still some text to process
 271          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 272          * shouldn't try reading from the input source any more.  We might
 273          * still have a bunch of tokens to match, though, because of
 274          * possible backing-up.
 275          *
 276          * When we actually see the EOF, we change the status to "new"
 277          * (via cmDependsFortran_yyrestart()), so that the user can continue scanning by
 278          * just pointing yyin at a new input file.
 279          */
 280 #define YY_BUFFER_EOF_PENDING 2
 281
 282         };
 283 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 284
 285 /* We provide macros for accessing buffer states in case in the
 286  * future we want to put the buffer states in a more general
 287  * "scanner state".
 288  *
 289  * Returns the top of the stack, or NULL.
 290  */
 291 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
 292                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
 293                           : NULL)
 294
 295 /* Same as previous macro, but useful when we know that the buffer stack is not
 296  * NULL or when we need an lvalue. For internal use only.
 297  */
 298 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 299
 300 void cmDependsFortran_yyrestart (FILE *input_file ,yyscan_t yyscanner );
 301 void cmDependsFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 302 YY_BUFFER_STATE cmDependsFortran_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
 303 void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 304 void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 305 void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 306 void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner );
 307
 308 static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner );
 309 static void cmDependsFortran_yy_load_buffer_state (yyscan_t yyscanner );
 310 static void cmDependsFortran_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
 311
 312 #define YY_FLUSH_BUFFER cmDependsFortran_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 313
 314 YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 315 YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
 316 YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 317
 318 void *cmDependsFortran_yyalloc (yy_size_t ,yyscan_t yyscanner );
 319 void *cmDependsFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
 320 void cmDependsFortran_yyfree (void * ,yyscan_t yyscanner );
 321
 322 #define yy_new_buffer cmDependsFortran_yy_create_buffer
 323
 324 #define yy_set_interactive(is_interactive) \
 325         { \
 326         if ( ! YY_CURRENT_BUFFER ){ \
 327         cmDependsFortran_yyensure_buffer_stack (yyscanner); \
 328                 YY_CURRENT_BUFFER_LVALUE =    \
 329             cmDependsFortran_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 330         } \
 331         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 332         }
 333
 334 #define yy_set_bol(at_bol) \
 335         { \
 336         if ( ! YY_CURRENT_BUFFER ){\
 337         cmDependsFortran_yyensure_buffer_stack (yyscanner); \
 338                 YY_CURRENT_BUFFER_LVALUE =    \
 339             cmDependsFortran_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 340         } \
 341         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 342         }
 343
 344 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 345
 346 /* Begin user sect3 */
 347
 348 #define cmDependsFortran_yywrap(n) 1
 349 #define YY_SKIP_YYWRAP
 350
 351 typedef unsigned char YY_CHAR;
 352
 353 typedef int yy_state_type;
 354
 355 #define yytext_ptr yytext_r
 356
 357 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
 358 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
 359 static int yy_get_next_buffer (yyscan_t yyscanner );
 360 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 361
 362 /* Done after the current pattern has been matched and before the
 363  * corresponding action - sets up yytext.
 364  */
 365 #define YY_DO_BEFORE_ACTION \
 366         yyg->yytext_ptr = yy_bp; \
 367         yyleng = (size_t) (yy_cp - yy_bp); \
 368         yyg->yy_hold_char = *yy_cp; \
 369         *yy_cp = '\0'; \
 370         yyg->yy_c_buf_p = yy_cp;
 371
 372 #define YY_NUM_RULES 44
 373 #define YY_END_OF_BUFFER 45
 374 /* This struct is not used in this scanner,
 375    but its presence is necessary. */
 376 struct yy_trans_info
 377         {
 378         flex_int32_t yy_verify;
 379         flex_int32_t yy_nxt;
 380         };
 381 static yyconst flex_int16_t yy_accept[165] =
 382     {   0,
 383         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 384        45,   39,   41,   40,   43,    1,   39,   32,    2,   34,
 385        39,   40,   37,   39,   38,   39,   38,   41,   39,   40,
 386        39,   38,    9,    8,    9,    4,    3,   39,    0,   10,
 387         0,    0,    0,    0,    0,   32,   32,   33,   35,   37,
 388        39,   38,    0,   42,   38,    0,    0,    0,    0,    0,
 389         0,    0,    0,   39,    0,   11,   38,    0,    0,    5,
 390         0,    0,    0,   28,    0,    0,   32,   32,   32,   32,
 391         0,    0,    0,    0,    0,   22,    0,    0,    0,    0,
 392         0,    6,    0,    0,    0,    0,    0,    0,    0,    0,
 393
 394         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 395         0,    0,   29,   30,    0,    0,    0,    0,    0,    0,
 396         0,   23,   24,    0,    0,    0,    0,    0,    0,    0,
 397         0,   31,   26,    0,    0,   19,    0,    0,   25,   20,
 398         0,    0,   18,    0,    0,   17,   27,    0,    0,   16,
 399        21,    0,    7,   36,    7,   14,    0,   13,   15,    0,
 400         0,    0,   12,    0
 401     } ;
 402
 403 static yyconst flex_int32_t yy_ec[256] =
 404     {   0,
 405         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 406         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 408         1,    5,    6,    7,    8,    9,    1,   10,   11,    1,
 409         1,   12,    1,   13,    1,    1,    1,   14,   14,   14,
 410        14,   14,   14,   14,   14,   14,   14,   15,   16,   17,
 411        18,   19,   20,    1,   21,   21,   22,   23,   24,   25,
 412        21,   21,   26,   21,   21,   27,   21,   28,   21,   21,
 413        21,   21,   29,   21,   30,   21,   21,   21,   21,   21,
 414         1,   31,    1,    1,   32,    1,   21,   21,   33,   34,
 415
 416        35,   36,   21,   21,   37,   21,   21,   38,   21,   39,
 417        21,   21,   21,   21,   40,   21,   41,   21,   21,   21,
 418        21,   21,    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         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 422         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 423         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 424         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 425         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 426
 427         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 428         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 429         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 430         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 431         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 432         1,    1,    1,    1,    1
 433     } ;
 434
 435 static yyconst flex_int32_t yy_meta[42] =
 436     {   0,
 437         1,    2,    2,    3,    4,    3,    3,    1,    1,    3,
 438         3,    1,    3,    5,    1,    3,    1,    3,    6,    1,
 439         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
 440         1,    5,    7,    7,    7,    7,    7,    7,    7,    7,
 441         7
 442     } ;
 443
 444 static yyconst flex_int16_t yy_base[174] =
 445     {   0,
 446         0,   40,    0,   41,  188,   48,   44,   54,   56,   65,
 447       186,    0,  505,  505,  171,  505,   81,   74,  505,  505,
 448       158,  505,  151,  137,    0,   85,  122,   87,  153,  145,
 449       194,  226,  505,  143,   91,  505,  505,    0,  142,  505,
 450       266,   34,   70,   74,   34,  122,  141,  505,    0,  505,
 451       112,    0,   98,  505,    0,  154,  306,    0,   43,  133,
 452       139,   46,  130,  347,  130,  505,    0,  121,  163,  179,
 453       104,  156,  129,  176,  147,  178,  214,  267,  273,  292,
 454       279,  179,  249,  280,  257,  265,  288,  289,  116,  107,
 455       317,  505,  287,  289,  291,  302,  307,  310,  307,  311,
 456
 457       316,  326,  329,  333,  332,  336,  347,  345,  349,  101,
 458        86,  346,  505,  505,  350,  351,  353,  350,  357,  362,
 459       362,  505,  505,  367,  369,  371,  366,  372,   56,   47,
 460       374,  505,  505,  374,  379,  505,  374,  387,  505,  505,
 461       387,  391,  505,  117,    0,  505,  505,  392,  394,  505,
 462       505,  394,  505,  505,  505,  505,  395,  419,  505,  429,
 463         0,   25,  505,  505,  446,  453,  459,  462,  469,  476,
 464       483,  490,  497
 465     } ;
 466
 467 static yyconst flex_int16_t yy_def[174] =
 468     {   0,
 469       164,    1,    1,    1,    1,    1,  165,  165,  165,  165,
 470       164,  166,  164,  164,  167,  164,  166,  164,  164,  164,
 471       166,  164,  164,  166,  168,  166,  168,  164,  166,  164,
 472       169,  164,  164,  164,  164,  164,  164,  166,  167,  164,
 473       164,  164,  164,  164,  164,  164,  170,  164,  166,  164,
 474       166,  168,  164,  164,   27,  164,  164,   57,  164,  164,
 475       164,  164,  164,  169,  169,  164,   32,  164,  164,  164,
 476       164,  164,  164,  164,  164,  164,  170,  170,  170,  170,
 477       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 478       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 479
 480       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 481       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 482       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 483       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 484       164,  164,  164,  171,  172,  164,  164,  164,  164,  164,
 485       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 486       173,  173,  164,    0,  164,  164,  164,  164,  164,  164,
 487       164,  164,  164
 488     } ;
 489
 490 static yyconst flex_int16_t yy_nxt[547] =
 491     {   0,
 492        12,   13,   14,   13,   13,   15,   16,   12,   17,   18,
 493        19,   12,   20,   12,   21,   22,   12,   23,   12,   24,
 494        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
 495        26,   27,   25,   25,   25,   25,   25,   25,   25,   25,
 496        25,   28,   28,  163,   28,   28,   34,   29,   29,   28,
 497        30,  145,   28,   35,   36,   29,   34,   71,   34,   31,
 498       144,   76,   37,   35,   36,   35,   83,   34,   71,   32,
 499        32,   37,   76,   88,   35,   46,   46,   83,   46,   47,
 500        32,   32,   41,   48,   88,   41,   53,   54,   56,   53,
 501       130,   56,   69,   70,   57,   69,   72,   73,   74,   53,
 502
 503        54,   75,   53,   42,   43,  129,   44,   72,   73,   74,
 504        45,  111,   75,   81,   42,   43,   81,   44,  154,  154,
 505       110,   45,   38,   46,   46,   90,   46,   47,   93,   38,
 506        38,   48,   66,   38,   89,   55,   38,   82,   38,   93,
 507        38,   38,   78,   46,   40,   78,   79,   68,   82,   63,
 508        80,   96,   38,   55,   58,   56,   51,   58,   56,   84,
 509        85,   57,   96,   86,   69,   70,   87,   69,   99,   50,
 510        84,   85,   49,   40,   86,   59,   60,   87,   61,   99,
 511        91,   94,   62,   91,   95,  164,   59,   60,   92,   61,
 512        30,  164,   94,   62,   64,   95,   66,  164,   97,  164,
 513
 514       100,   64,   64,   98,  164,   64,  101,   64,   64,   97,
 515        64,  100,   64,   64,   98,   78,   46,  101,   78,   79,
 516       164,  164,  164,   80,   64,   64,   65,   65,   66,   65,
 517        65,   65,   65,   65,   65,   65,   65,   65,   65,   67,
 518        65,   65,   65,   65,   65,   65,   67,   67,   67,   67,
 519        67,   67,   67,   67,   67,   67,   65,   67,   67,   67,
 520        67,   67,   67,   67,   67,   67,   67,   41,   78,   46,
 521        41,   78,   79,  102,   78,   46,   80,   78,   79,  105,
 522        81,  164,   80,   81,  102,  164,  164,  106,   42,   43,
 523       105,   44,  107,   78,   46,   45,   78,   79,  106,   42,
 524
 525        43,   80,   44,  107,   82,  103,   45,   58,  104,  108,
 526        58,  109,  112,  113,  114,   82,  103,  164,   91,  104,
 527       108,   91,  109,  112,  113,  114,   92,  115,   59,   60,
 528       116,   61,  117,  118,  119,   62,  164,  120,  115,   59,
 529        60,  116,   61,  117,  118,  119,   62,   64,  120,   66,
 530       164,  121,  164,  122,   64,   64,  123,  124,   64,  125,
 531        64,   64,  121,   64,  122,   64,   64,  123,  124,  126,
 532       125,  127,  128,  131,  132,  133,  134,   64,   64,  135,
 533       126,  136,  127,  128,  131,  132,  133,  134,  137,  138,
 534       135,  139,  136,  140,  141,  142,  143,  146,  147,  137,
 535
 536       138,  148,  139,  149,  140,  141,  142,  143,  146,  147,
 537       150,  151,  148,  152,  149,  156,  157,  158,  159,  164,
 538       160,  150,  151,  160,  152,  164,  156,  157,  158,  159,
 539       160,  164,  164,  160,  164,  161,  164,  164,  164,  164,
 540       164,  164,  164,  164,  164,  161,   33,   33,   33,   33,
 541        33,   33,   33,   38,  164,  164,  164,   38,   38,   39,
 542        39,   39,   39,   39,   39,   39,   52,  164,   52,   65,
 543        65,   65,   65,   65,   65,   65,   77,   77,   77,   77,
 544        77,   77,   77,  153,  153,  153,  164,  153,  153,  153,
 545       155,  164,  155,  164,  155,  155,  155,  162,  162,  162,
 546
 547       162,  162,  164,  162,   11,  164,  164,  164,  164,  164,
 548       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 549       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 550       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 551       164,  164,  164,  164,  164,  164
 552     } ;
 553
 554 static yyconst flex_int16_t yy_chk[547] =
 555     {   0,
 556         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 557         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 558         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 559         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 560         1,    2,    4,  162,    2,    4,    7,    2,    4,    6,
 561         6,  130,    6,    7,    7,    6,    8,   42,    9,    6,
 562       129,   45,    9,    8,    8,    9,   59,   10,   42,    6,
 563         6,   10,   45,   62,   10,   18,   18,   59,   18,   18,
 564         6,    6,   17,   18,   62,   17,   26,   26,   28,   26,
 565       111,   28,   35,   35,   28,   35,   43,   43,   44,   53,
 566
 567        53,   44,   53,   17,   17,  110,   17,   43,   43,   44,
 568        17,   90,   44,   51,   17,   17,   51,   17,  144,  144,
 569        89,   17,   27,   46,   46,   68,   46,   46,   71,   27,
 570        27,   46,   65,   27,   63,   27,   27,   51,   27,   71,
 571        27,   27,   47,   47,   39,   47,   47,   34,   51,   30,
 572        47,   73,   27,   27,   29,   56,   24,   29,   56,   60,
 573        60,   56,   73,   61,   69,   69,   61,   69,   75,   23,
 574        60,   60,   21,   15,   61,   29,   29,   61,   29,   75,
 575        70,   72,   29,   70,   72,   11,   29,   29,   70,   29,
 576         5,    0,   72,   29,   31,   72,   31,    0,   74,    0,
 577
 578        76,   31,   31,   74,    0,   31,   82,   31,   31,   74,
 579        31,   76,   31,   31,   74,   77,   77,   82,   77,   77,
 580         0,    0,    0,   77,   31,   31,   32,   32,   32,   32,
 581        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 582        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 583        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 584        32,   32,   32,   32,   32,   32,   32,   41,   78,   78,
 585        41,   78,   78,   83,   79,   79,   78,   79,   79,   85,
 586        81,    0,   79,   81,   83,    0,    0,   86,   41,   41,
 587        85,   41,   86,   80,   80,   41,   80,   80,   86,   41,
 588
 589        41,   80,   41,   86,   81,   84,   41,   57,   84,   87,
 590        57,   88,   93,   94,   95,   81,   84,    0,   91,   84,
 591        87,   91,   88,   93,   94,   95,   91,   96,   57,   57,
 592        97,   57,   98,   99,  100,   57,    0,  101,   96,   57,
 593        57,   97,   57,   98,   99,  100,   57,   64,  101,   64,
 594         0,  102,    0,  103,   64,   64,  104,  105,   64,  106,
 595        64,   64,  102,   64,  103,   64,   64,  104,  105,  107,
 596       106,  108,  109,  112,  115,  116,  117,   64,   64,  118,
 597       107,  119,  108,  109,  112,  115,  116,  117,  120,  121,
 598       118,  124,  119,  125,  126,  127,  128,  131,  134,  120,
 599
 600       121,  135,  124,  137,  125,  126,  127,  128,  131,  134,
 601       138,  141,  135,  142,  137,  148,  149,  152,  157,    0,
 602       158,  138,  141,  158,  142,    0,  148,  149,  152,  157,
 603       160,    0,    0,  160,    0,  158,    0,    0,    0,    0,
 604         0,    0,    0,    0,    0,  160,  165,  165,  165,  165,
 605       165,  165,  165,  166,    0,    0,    0,  166,  166,  167,
 606       167,  167,  167,  167,  167,  167,  168,    0,  168,  169,
 607       169,  169,  169,  169,  169,  169,  170,  170,  170,  170,
 608       170,  170,  170,  171,  171,  171,    0,  171,  171,  171,
 609       172,    0,  172,    0,  172,  172,  172,  173,  173,  173,
 610
 611       173,  173,    0,  173,  164,  164,  164,  164,  164,  164,
 612       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 613       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 614       164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
 615       164,  164,  164,  164,  164,  164
 616     } ;
 617
 618 /* The intent behind this definition is that it'll catch
 619  * any uses of REJECT which flex missed.
 620  */
 621 #define REJECT reject_used_but_not_detected
 622 #define yymore() yymore_used_but_not_detected
 623 #define YY_MORE_ADJ 0
 624 #define YY_RESTORE_YY_MORE_OFFSET
 625 #line 1 "cmDependsFortranLexer.in.l"
 626 #line 2 "cmDependsFortranLexer.in.l"
 627 /*============================================================================
 628   CMake - Cross Platform Makefile Generator
 629   Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
 630
 631   Distributed under the OSI-approved BSD License (the "License");
 632   see accompanying file Copyright.txt for details.
 633
 634   This software is distributed WITHOUT ANY WARRANTY; without even the
 635   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 636   See the License for more information.
 637 ============================================================================*/
 638 /*-------------------------------------------------------------------------
 639   Portions of this source have been derived from makedepf90 version 2.8.8,
 640
 641    Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
 642
 643   The code was originally distributed under the GPL but permission
 644   from the copyright holder has been obtained to distribute this
 645   derived work under the CMake license.
 646 -------------------------------------------------------------------------*/
 647
 648 /*
 649
 650 This file must be translated to C and modified to build everywhere.
 651
 652 Run flex like this:
 653
 654   flex -i --prefix=cmDependsFortran_yy --header-file=cmDependsFortranLexer.h -ocmDependsFortranLexer.cxx cmDependsFortranLexer.in.l
 655
 656 Modify cmDependsFortranLexer.cxx:
 657   - remove TABs
 658   - remove "yyscanner" argument from these methods:
 659       yy_fatal_error, cmDependsFortran_yyalloc, cmDependsFortran_yyrealloc, cmDependsFortran_yyfree
 660   - remove "yyscanner = NULL" from end of cmDependsFortran_yylex_destroy
 661   - remove all YY_BREAK lines occurring right after return statements
 662   - change while ( 1 ) to for(;;)
 663
 664 Modify cmDependsFortranLexer.h:
 665   - remove TABs
 666   - remove the yy_init_globals function
 667   - remove the block that includes unistd.h
 668   - remove #line directives (avoids bogus warning on old Sun)
 669
 670 */
 671
 672 #include "cmStandardLexer.h"
 673
 674 #define cmDependsFortranLexer_cxx
 675 #include "cmDependsFortranParser.h" /* Interface to parser object.  */
 676
 677 /* Replace the lexer input function.  */
 678 #undef YY_INPUT
 679 #define YY_INPUT(buf, result, max_size) \
 680   { result = cmDependsFortranParser_Input(yyextra, buf, max_size); }
 681
 682 /* Include the set of tokens from the parser.  */
 683 #include "cmDependsFortranParserTokens.h"
 684
 685 /*--------------------------------------------------------------------------*/
 686
 687
 688 #line 678 "cmDependsFortranLexer.cxx"
 689
 690 #define INITIAL 0
 691 #define free_fmt 1
 692 #define fixed_fmt 2
 693 #define str_sq 3
 694 #define str_dq 4
 695
 696 #ifndef YY_NO_UNISTD_H
 697 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 698  * down here because we want the user's section 1 to have been scanned first.
 699  * The user has a chance to override it with an option.
 700  */
 701 #include <unistd.h>
 702 #endif
 703
 704 #ifndef YY_EXTRA_TYPE
 705 #define YY_EXTRA_TYPE void *
 706 #endif
 707
 708 /* Holds the entire state of the reentrant scanner. */
 709 struct yyguts_t
 710     {
 711
 712     /* User-defined. Not touched by flex. */
 713     YY_EXTRA_TYPE yyextra_r;
 714
 715     /* The rest are the same as the globals declared in the non-reentrant scanner. */
 716     FILE *yyin_r, *yyout_r;
 717     size_t yy_buffer_stack_top; /**< index of top of stack. */
 718     size_t yy_buffer_stack_max; /**< capacity of stack. */
 719     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
 720     char yy_hold_char;
 721     int yy_n_chars;
 722     int yyleng_r;
 723     char *yy_c_buf_p;
 724     int yy_init;
 725     int yy_start;
 726     int yy_did_buffer_switch_on_eof;
 727     int yy_start_stack_ptr;
 728     int yy_start_stack_depth;
 729     int *yy_start_stack;
 730     yy_state_type yy_last_accepting_state;
 731     char* yy_last_accepting_cpos;
 732
 733     int yylineno_r;
 734     int yy_flex_debug_r;
 735
 736     char *yytext_r;
 737     int yy_more_flag;
 738     int yy_more_len;
 739
 740     }; /* end struct yyguts_t */
 741
 742 static int yy_init_globals (yyscan_t yyscanner );
 743
 744 int cmDependsFortran_yylex_init (yyscan_t* scanner);
 745
 746 int cmDependsFortran_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
 747
 748 /* Accessor methods to globals.
 749    These are made visible to non-reentrant scanners for convenience. */
 750
 751 int cmDependsFortran_yylex_destroy (yyscan_t yyscanner );
 752
 753 int cmDependsFortran_yyget_debug (yyscan_t yyscanner );
 754
 755 void cmDependsFortran_yyset_debug (int debug_flag ,yyscan_t yyscanner );
 756
 757 YY_EXTRA_TYPE cmDependsFortran_yyget_extra (yyscan_t yyscanner );
 758
 759 void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 760
 761 FILE *cmDependsFortran_yyget_in (yyscan_t yyscanner );
 762
 763 void cmDependsFortran_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
 764
 765 FILE *cmDependsFortran_yyget_out (yyscan_t yyscanner );
 766
 767 void cmDependsFortran_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 768
 769 int cmDependsFortran_yyget_leng (yyscan_t yyscanner );
 770
 771 char *cmDependsFortran_yyget_text (yyscan_t yyscanner );
 772
 773 int cmDependsFortran_yyget_lineno (yyscan_t yyscanner );
 774
 775 void cmDependsFortran_yyset_lineno (int line_number ,yyscan_t yyscanner );
 776
 777 /* Macros after this point can all be overridden by user definitions in
 778  * section 1.
 779  */
 780
 781 #ifndef YY_SKIP_YYWRAP
 782 #ifdef __cplusplus
 783 extern "C" int cmDependsFortran_yywrap (yyscan_t yyscanner );
 784 #else
 785 extern int cmDependsFortran_yywrap (yyscan_t yyscanner );
 786 #endif
 787 #endif
 788
 789     static void yyunput (int c,char *buf_ptr  ,yyscan_t yyscanner);
 790
 791 #ifndef yytext_ptr
 792 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 793 #endif
 794
 795 #ifdef YY_NEED_STRLEN
 796 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 797 #endif
 798
 799 #ifndef YY_NO_INPUT
 800
 801 #ifdef __cplusplus
 802 static int yyinput (yyscan_t yyscanner );
 803 #else
 804 static int input (yyscan_t yyscanner );
 805 #endif
 806
 807 #endif
 808
 809 /* Amount of stuff to slurp up with each read. */
 810 #ifndef YY_READ_BUF_SIZE
 811 #ifdef __ia64__
 812 /* On IA-64, the buffer size is 16k, not 8k */
 813 #define YY_READ_BUF_SIZE 16384
 814 #else
 815 #define YY_READ_BUF_SIZE 8192
 816 #endif /* __ia64__ */
 817 #endif
 818
 819 /* Copy whatever the last rule matched to the standard output. */
 820 #ifndef ECHO
 821 /* This used to be an fputs(), but since the string might contain NUL's,
 822  * we now use fwrite().
 823  */
 824 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 825 #endif
 826
 827 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 828  * is returned in "result".
 829  */
 830 #ifndef YY_INPUT
 831 #define YY_INPUT(buf,result,max_size) \
 832         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 833                 { \
 834                 int c = '*'; \
 835                 size_t n; \
 836                 for ( n = 0; n < max_size && \
 837                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 838                         buf[n] = (char) c; \
 839                 if ( c == '\n' ) \
 840                         buf[n++] = (char) c; \
 841                 if ( c == EOF && ferror( yyin ) ) \
 842                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 843                 result = n; \
 844                 } \
 845         else \
 846                 { \
 847                 errno=0; \
 848                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 849                         { \
 850                         if( errno != EINTR) \
 851                                 { \
 852                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 853                                 break; \
 854                                 } \
 855                         errno=0; \
 856                         clearerr(yyin); \
 857                         } \
 858                 }\
 859 \
 860
 861 #endif
 862
 863 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 864  * we don't want an extra ';' after the "return" because that will cause
 865  * some compilers to complain about unreachable statements.
 866  */
 867 #ifndef yyterminate
 868 #define yyterminate() return YY_NULL
 869 #endif
 870
 871 /* Number of entries by which start-condition stack grows. */
 872 #ifndef YY_START_STACK_INCR
 873 #define YY_START_STACK_INCR 25
 874 #endif
 875
 876 /* Report a fatal error. */
 877 #ifndef YY_FATAL_ERROR
 878 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 879 #endif
 880
 881 /* end tables serialization structures and prototypes */
 882
 883 /* Default declaration of generated scanner - a define so the user can
 884  * easily add parameters.
 885  */
 886 #ifndef YY_DECL
 887 #define YY_DECL_IS_OURS 1
 888
 889 extern int cmDependsFortran_yylex (yyscan_t yyscanner);
 890
 891 #define YY_DECL int cmDependsFortran_yylex (yyscan_t yyscanner)
 892 #endif /* !YY_DECL */
 893
 894 /* Code executed at the beginning of each rule, after yytext and yyleng
 895  * have been set up.
 896  */
 897 #ifndef YY_USER_ACTION
 898 #define YY_USER_ACTION
 899 #endif
 900
 901 /* Code executed at the end of each rule. */
 902 #ifndef YY_BREAK
 903 #define YY_BREAK break;
 904 #endif
 905
 906 #define YY_RULE_SETUP \
 907         if ( yyleng > 0 ) \
 908                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
 909                                 (yytext[yyleng - 1] == '\n'); \
 910         YY_USER_ACTION
 911
 912 /** The main scanner function which does all the work.
 913  */
 914 YY_DECL
 915 {
 916         yy_state_type yy_current_state;
 917         char *yy_cp, *yy_bp;
 918         int yy_act;
 919     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 920
 921 #line 71 "cmDependsFortranLexer.in.l"
 922
 923
 924 #line 914 "cmDependsFortranLexer.cxx"
 925
 926         if ( !yyg->yy_init )
 927                 {
 928                 yyg->yy_init = 1;
 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                         cmDependsFortran_yyensure_buffer_stack (yyscanner);
 945                         YY_CURRENT_BUFFER_LVALUE =
 946                                 cmDependsFortran_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 947                 }
 948
 949                 cmDependsFortran_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_current_state += YY_AT_BOL();
 966 yy_match:
 967                 do
 968                         {
 969                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 970                         if ( yy_accept[yy_current_state] )
 971                                 {
 972                                 yyg->yy_last_accepting_state = yy_current_state;
 973                                 yyg->yy_last_accepting_cpos = yy_cp;
 974                                 }
 975                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 976                                 {
 977                                 yy_current_state = (int) yy_def[yy_current_state];
 978                                 if ( yy_current_state >= 165 )
 979                                         yy_c = yy_meta[(unsigned int) yy_c];
 980                                 }
 981                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 982                         ++yy_cp;
 983                         }
 984                 while ( yy_base[yy_current_state] != 505 );
 985
 986 yy_find_action:
 987                 yy_act = yy_accept[yy_current_state];
 988                 if ( yy_act == 0 )
 989                         { /* have to back up */
 990                         yy_cp = yyg->yy_last_accepting_cpos;
 991                         yy_current_state = yyg->yy_last_accepting_state;
 992                         yy_act = yy_accept[yy_current_state];
 993                         }
 994
 995                 YY_DO_BEFORE_ACTION;
 996
 997 do_action:      /* This label is used only to access EOF actions. */
 998
 999                 switch ( yy_act )
1000         { /* beginning of action switch */
1001                         case 0: /* must back up */
1002                         /* undo the effects of YY_DO_BEFORE_ACTION */
1003                         *yy_cp = yyg->yy_hold_char;
1004                         yy_cp = yyg->yy_last_accepting_cpos;
1005                         yy_current_state = yyg->yy_last_accepting_state;
1006                         goto yy_find_action;
1007
1008 case 1:
1009 YY_RULE_SETUP
1010 #line 73 "cmDependsFortranLexer.in.l"
1011 {
1012   cmDependsFortranParser_StringStart(yyextra);
1013   cmDependsFortranParser_SetOldStartcond(yyextra, YY_START);
1014   BEGIN(str_dq);
1015 }
1016         YY_BREAK
1017 case 2:
1018 YY_RULE_SETUP
1019 #line 79 "cmDependsFortranLexer.in.l"
1020 {
1021   cmDependsFortranParser_StringStart(yyextra);
1022   cmDependsFortranParser_SetOldStartcond(yyextra, YY_START);
1023   BEGIN(str_sq);
1024 }
1025         YY_BREAK
1026 case 3:
1027 #line 86 "cmDependsFortranLexer.in.l"
1028 case 4:
1029 YY_RULE_SETUP
1030 #line 86 "cmDependsFortranLexer.in.l"
1031 {
1032   BEGIN(cmDependsFortranParser_GetOldStartcond(yyextra) );
1033   yylvalp->string = strdup(cmDependsFortranParser_StringEnd(yyextra));
1034   return STRING;
1035 }
1036 case 5:
1037 /* rule 5 can match eol */
1038 #line 93 "cmDependsFortranLexer.in.l"
1039 case 6:
1040 /* rule 6 can match eol */
1041 YY_RULE_SETUP
1042 #line 93 "cmDependsFortranLexer.in.l"
1043 /* Ignore (continued strings, free fmt) */
1044         YY_BREAK
1045 case 7:
1046 /* rule 7 can match eol */
1047 YY_RULE_SETUP
1048 #line 95 "cmDependsFortranLexer.in.l"
1049 {
1050   if (cmDependsFortranParser_GetOldStartcond(yyextra) == fixed_fmt)
1051     ; /* Ignore (cont. strings, fixed fmt) */
1052   else
1053     {
1054     unput(yytext[strlen(yytext)-1]);
1055     }
1056 }
1057         YY_BREAK
1058 case 8:
1059 /* rule 8 can match eol */
1060 YY_RULE_SETUP
1061 #line 105 "cmDependsFortranLexer.in.l"
1062 {
1063   unput ('\n');
1064   BEGIN(INITIAL);
1065   return UNTERMINATED_STRING;
1066 }
1067 case 9:
1068 YY_RULE_SETUP
1069 #line 111 "cmDependsFortranLexer.in.l"
1070 {
1071   cmDependsFortranParser_StringAppend(yyextra, yytext[0]);
1072 }
1073         YY_BREAK
1074 case 10:
1075 /* rule 10 can match eol */
1076 YY_RULE_SETUP
1077 #line 115 "cmDependsFortranLexer.in.l"
1078 { return EOSTMT; } /* Treat comments like */
1079 case 11:
1080 /* rule 11 can match eol */
1081 YY_RULE_SETUP
1082 #line 116 "cmDependsFortranLexer.in.l"
1083 { return EOSTMT; } /* empty lines */
1084 case 12:
1085 /* rule 12 can match eol */
1086 YY_RULE_SETUP
1087 #line 118 "cmDependsFortranLexer.in.l"
1088 {
1089   yytext[yyleng-1] = 0;
1090   yylvalp->string = strdup(strchr(yytext, '<')+1);
1091   return CPP_INCLUDE_ANGLE;
1092 }
1093 case 13:
1094 YY_RULE_SETUP
1095 #line 123 "cmDependsFortranLexer.in.l"
1096 { return CPP_INCLUDE; }
1097 case 14:
1098 YY_RULE_SETUP
1099 #line 124 "cmDependsFortranLexer.in.l"
1100 { return F90PPR_INCLUDE; }
1101 case 15:
1102 YY_RULE_SETUP
1103 #line 125 "cmDependsFortranLexer.in.l"
1104 { return COCO_INCLUDE; }
1105 case 16:
1106 YY_RULE_SETUP
1107 #line 127 "cmDependsFortranLexer.in.l"
1108 { return CPP_DEFINE; }
1109 case 17:
1110 YY_RULE_SETUP
1111 #line 128 "cmDependsFortranLexer.in.l"
1112 { return F90PPR_DEFINE; }
1113 case 18:
1114 YY_RULE_SETUP
1115 #line 130 "cmDependsFortranLexer.in.l"
1116 { return CPP_UNDEF; }
1117 case 19:
1118 YY_RULE_SETUP
1119 #line 131 "cmDependsFortranLexer.in.l"
1120 { return F90PPR_UNDEF; }
1121 case 20:
1122 YY_RULE_SETUP
1123 #line 133 "cmDependsFortranLexer.in.l"
1124 { return CPP_IFDEF; }
1125 case 21:
1126 YY_RULE_SETUP
1127 #line 134 "cmDependsFortranLexer.in.l"
1128 { return CPP_IFNDEF; }
1129 case 22:
1130 YY_RULE_SETUP
1131 #line 135 "cmDependsFortranLexer.in.l"
1132 { return CPP_IF; }
1133 case 23:
1134 YY_RULE_SETUP
1135 #line 136 "cmDependsFortranLexer.in.l"
1136 { return CPP_ELIF; }
1137 case 24:
1138 YY_RULE_SETUP
1139 #line 137 "cmDependsFortranLexer.in.l"
1140 { return CPP_ELSE; }
1141 case 25:
1142 YY_RULE_SETUP
1143 #line 138 "cmDependsFortranLexer.in.l"
1144 { return CPP_ENDIF; }
1145 case 26:
1146 YY_RULE_SETUP
1147 #line 140 "cmDependsFortranLexer.in.l"
1148 { return F90PPR_IFDEF; }
1149 case 27:
1150 YY_RULE_SETUP
1151 #line 141 "cmDependsFortranLexer.in.l"
1152 { return F90PPR_IFNDEF; }
1153 case 28:
1154 YY_RULE_SETUP
1155 #line 142 "cmDependsFortranLexer.in.l"
1156 { return F90PPR_IF; }
1157 case 29:
1158 YY_RULE_SETUP
1159 #line 143 "cmDependsFortranLexer.in.l"
1160 { return F90PPR_ELIF; }
1161 case 30:
1162 YY_RULE_SETUP
1163 #line 144 "cmDependsFortranLexer.in.l"
1164 { return F90PPR_ELSE; }
1165 case 31:
1166 YY_RULE_SETUP
1167 #line 145 "cmDependsFortranLexer.in.l"
1168 { return F90PPR_ENDIF; }
1169 /* Line continuations, possible involving comments.  */
1170 case 32:
1171 /* rule 32 can match eol */
1172 YY_RULE_SETUP
1173 #line 148 "cmDependsFortranLexer.in.l"
1174
1175         YY_BREAK
1176 case 33:
1177 /* rule 33 can match eol */
1178 YY_RULE_SETUP
1179 #line 149 "cmDependsFortranLexer.in.l"
1180
1181         YY_BREAK
1182 case 34:
1183 YY_RULE_SETUP
1184 #line 151 "cmDependsFortranLexer.in.l"
1185 { return COMMA; }
1186 case 35:
1187 YY_RULE_SETUP
1188 #line 153 "cmDependsFortranLexer.in.l"
1189 { return DCOLON; }
1190 case 36:
1191 /* rule 36 can match eol */
1192 YY_RULE_SETUP
1193 #line 155 "cmDependsFortranLexer.in.l"
1194 { return GARBAGE; }
1195 case 37:
1196 YY_RULE_SETUP
1197 #line 157 "cmDependsFortranLexer.in.l"
1198 { return ASSIGNMENT_OP; }
1199 case 38:
1200 YY_RULE_SETUP
1201 #line 159 "cmDependsFortranLexer.in.l"
1202 {
1203   yylvalp->string = strdup(yytext);
1204   return WORD;
1205 }
1206 case 39:
1207 YY_RULE_SETUP
1208 #line 164 "cmDependsFortranLexer.in.l"
1209 { return GARBAGE; }
1210 case 40:
1211 /* rule 40 can match eol */
1212 YY_RULE_SETUP
1213 #line 166 "cmDependsFortranLexer.in.l"
1214 { return EOSTMT; }
1215 case 41:
1216 YY_RULE_SETUP
1217 #line 169 "cmDependsFortranLexer.in.l"
1218 /* Ignore */
1219         YY_BREAK
1220 case 42:
1221 /* rule 42 can match eol */
1222 YY_RULE_SETUP
1223 #line 170 "cmDependsFortranLexer.in.l"
1224 /* Ignore line-endings preceeded by \ */
1225         YY_BREAK
1226 case 43:
1227 YY_RULE_SETUP
1228 #line 172 "cmDependsFortranLexer.in.l"
1229 { return *yytext; }
1230 case YY_STATE_EOF(INITIAL):
1231 case YY_STATE_EOF(free_fmt):
1232 case YY_STATE_EOF(fixed_fmt):
1233 case YY_STATE_EOF(str_sq):
1234 case YY_STATE_EOF(str_dq):
1235 #line 174 "cmDependsFortranLexer.in.l"
1236 {
1237   if(!cmDependsFortranParser_FilePop(yyextra) )
1238     {
1239     return YY_NULL;
1240     }
1241 }
1242         YY_BREAK
1243 case 44:
1244 YY_RULE_SETUP
1245 #line 181 "cmDependsFortranLexer.in.l"
1246 ECHO;
1247         YY_BREAK
1248 #line 1270 "cmDependsFortranLexer.cxx"
1249
1250         case YY_END_OF_BUFFER:
1251                 {
1252                 /* Amount of text matched not including the EOB char. */
1253                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1254
1255                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1256                 *yy_cp = yyg->yy_hold_char;
1257                 YY_RESTORE_YY_MORE_OFFSET
1258
1259                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1260                         {
1261                         /* We're scanning a new file or input source.  It's
1262                          * possible that this happened because the user
1263                          * just pointed yyin at a new source and called
1264                          * cmDependsFortran_yylex().  If so, then we have to assure
1265                          * consistency between YY_CURRENT_BUFFER and our
1266                          * globals.  Here is the right place to do so, because
1267                          * this is the first action (other than possibly a
1268                          * back-up) that will match for the new input source.
1269                          */
1270                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1271                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1272                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1273                         }
1274
1275                 /* Note that here we test for yy_c_buf_p "<=" to the position
1276                  * of the first EOB in the buffer, since yy_c_buf_p will
1277                  * already have been incremented past the NUL character
1278                  * (since all states make transitions on EOB to the
1279                  * end-of-buffer state).  Contrast this with the test
1280                  * in input().
1281                  */
1282                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1283                         { /* This was really a NUL. */
1284                         yy_state_type yy_next_state;
1285
1286                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1287
1288                         yy_current_state = yy_get_previous_state( yyscanner );
1289
1290                         /* Okay, we're now positioned to make the NUL
1291                          * transition.  We couldn't have
1292                          * yy_get_previous_state() go ahead and do it
1293                          * for us because it doesn't know how to deal
1294                          * with the possibility of jamming (and we don't
1295                          * want to build jamming into it because then it
1296                          * will run more slowly).
1297                          */
1298
1299                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1300
1301                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1302
1303                         if ( yy_next_state )
1304                                 {
1305                                 /* Consume the NUL. */
1306                                 yy_cp = ++yyg->yy_c_buf_p;
1307                                 yy_current_state = yy_next_state;
1308                                 goto yy_match;
1309                                 }
1310
1311                         else
1312                                 {
1313                                 yy_cp = yyg->yy_c_buf_p;
1314                                 goto yy_find_action;
1315                                 }
1316                         }
1317
1318                 else switch ( yy_get_next_buffer( yyscanner ) )
1319                         {
1320                         case EOB_ACT_END_OF_FILE:
1321                                 {
1322                                 yyg->yy_did_buffer_switch_on_eof = 0;
1323
1324                                 if ( cmDependsFortran_yywrap(yyscanner ) )
1325                                         {
1326                                         /* Note: because we've taken care in
1327                                          * yy_get_next_buffer() to have set up
1328                                          * yytext, we can now set up
1329                                          * yy_c_buf_p so that if some total
1330                                          * hoser (like flex itself) wants to
1331                                          * call the scanner after we return the
1332                                          * YY_NULL, it'll still work - another
1333                                          * YY_NULL will get returned.
1334                                          */
1335                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1336
1337                                         yy_act = YY_STATE_EOF(YY_START);
1338                                         goto do_action;
1339                                         }
1340
1341                                 else
1342                                         {
1343                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1344                                                 YY_NEW_FILE;
1345                                         }
1346                                 break;
1347                                 }
1348
1349                         case EOB_ACT_CONTINUE_SCAN:
1350                                 yyg->yy_c_buf_p =
1351                                         yyg->yytext_ptr + yy_amount_of_matched_text;
1352
1353                                 yy_current_state = yy_get_previous_state( yyscanner );
1354
1355                                 yy_cp = yyg->yy_c_buf_p;
1356                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1357                                 goto yy_match;
1358
1359                         case EOB_ACT_LAST_MATCH:
1360                                 yyg->yy_c_buf_p =
1361                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1362
1363                                 yy_current_state = yy_get_previous_state( yyscanner );
1364
1365                                 yy_cp = yyg->yy_c_buf_p;
1366                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1367                                 goto yy_find_action;
1368                         }
1369                 break;
1370                 }
1371
1372         default:
1373                 YY_FATAL_ERROR(
1374                         "fatal flex scanner internal error--no action found" );
1375         } /* end of action switch */
1376                 } /* end of scanning one token */
1377 } /* end of cmDependsFortran_yylex */
1378
1379 /* yy_get_next_buffer - try to read in a new buffer
1380  *
1381  * Returns a code representing an action:
1382  *      EOB_ACT_LAST_MATCH -
1383  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1384  *      EOB_ACT_END_OF_FILE - end of file
1385  */
1386 static int yy_get_next_buffer (yyscan_t yyscanner)
1387 {
1388     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1389         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1390         char *source = yyg->yytext_ptr;
1391         int number_to_move, i;
1392         int ret_val;
1393
1394         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1395                 YY_FATAL_ERROR(
1396                 "fatal flex scanner internal error--end of buffer missed" );
1397
1398         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1399                 { /* Don't try to fill the buffer, so this is an EOF. */
1400                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1401                         {
1402                         /* We matched a single character, the EOB, so
1403                          * treat this as a final EOF.
1404                          */
1405                         return EOB_ACT_END_OF_FILE;
1406                         }
1407
1408                 else
1409                         {
1410                         /* We matched some text prior to the EOB, first
1411                          * process it.
1412                          */
1413                         return EOB_ACT_LAST_MATCH;
1414                         }
1415                 }
1416
1417         /* Try to read more data. */
1418
1419         /* First move last chars to start of buffer. */
1420         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1421
1422         for ( i = 0; i < number_to_move; ++i )
1423                 *(dest++) = *(source++);
1424
1425         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1426                 /* don't do the read, it's not guaranteed to return an EOF,
1427                  * just force an EOF
1428                  */
1429                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1430
1431         else
1432                 {
1433                         int num_to_read =
1434                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1435
1436                 while ( num_to_read <= 0 )
1437                         { /* Not enough room in the buffer - grow it. */
1438
1439                         /* just a shorter name for the current buffer */
1440                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1441
1442                         int yy_c_buf_p_offset =
1443                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1444
1445                         if ( b->yy_is_our_buffer )
1446                                 {
1447                                 int new_size = b->yy_buf_size * 2;
1448
1449                                 if ( new_size <= 0 )
1450                                         b->yy_buf_size += b->yy_buf_size / 8;
1451                                 else
1452                                         b->yy_buf_size *= 2;
1453
1454                                 b->yy_ch_buf = (char *)
1455                                         /* Include room in for 2 EOB chars. */
1456                                         cmDependsFortran_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1457                                 }
1458                         else
1459                                 /* Can't grow it, we don't own it. */
1460                                 b->yy_ch_buf = 0;
1461
1462                         if ( ! b->yy_ch_buf )
1463                                 YY_FATAL_ERROR(
1464                                 "fatal error - scanner input buffer overflow" );
1465
1466                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1467
1468                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1469                                                 number_to_move - 1;
1470
1471                         }
1472
1473                 if ( num_to_read > YY_READ_BUF_SIZE )
1474                         num_to_read = YY_READ_BUF_SIZE;
1475
1476                 /* Read in more data. */
1477                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1478                         yyg->yy_n_chars, (size_t) num_to_read );
1479
1480                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1481                 }
1482
1483         if ( yyg->yy_n_chars == 0 )
1484                 {
1485                 if ( number_to_move == YY_MORE_ADJ )
1486                         {
1487                         ret_val = EOB_ACT_END_OF_FILE;
1488                         cmDependsFortran_yyrestart(yyin  ,yyscanner);
1489                         }
1490
1491                 else
1492                         {
1493                         ret_val = EOB_ACT_LAST_MATCH;
1494                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1495                                 YY_BUFFER_EOF_PENDING;
1496                         }
1497                 }
1498
1499         else
1500                 ret_val = EOB_ACT_CONTINUE_SCAN;
1501
1502         if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1503                 /* Extend the array by 50%, plus the number we really need. */
1504                 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1505                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) cmDependsFortran_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1506                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1507                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1508         }
1509
1510         yyg->yy_n_chars += number_to_move;
1511         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1512         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1513
1514         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1515
1516         return ret_val;
1517 }
1518
1519 /* yy_get_previous_state - get the state just before the EOB char was reached */
1520
1521     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1522 {
1523         yy_state_type yy_current_state;
1524         char *yy_cp;
1525     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1526
1527         yy_current_state = yyg->yy_start;
1528         yy_current_state += YY_AT_BOL();
1529
1530         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1531                 {
1532                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1533                 if ( yy_accept[yy_current_state] )
1534                         {
1535                         yyg->yy_last_accepting_state = yy_current_state;
1536                         yyg->yy_last_accepting_cpos = yy_cp;
1537                         }
1538                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1539                         {
1540                         yy_current_state = (int) yy_def[yy_current_state];
1541                         if ( yy_current_state >= 165 )
1542                                 yy_c = yy_meta[(unsigned int) yy_c];
1543                         }
1544                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1545                 }
1546
1547         return yy_current_state;
1548 }
1549
1550 /* yy_try_NUL_trans - try to make a transition on the NUL character
1551  *
1552  * synopsis
1553  *      next_state = yy_try_NUL_trans( current_state );
1554  */
1555     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
1556 {
1557         int yy_is_jam;
1558     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1559         char *yy_cp = yyg->yy_c_buf_p;
1560
1561         YY_CHAR yy_c = 1;
1562         if ( yy_accept[yy_current_state] )
1563                 {
1564                 yyg->yy_last_accepting_state = yy_current_state;
1565                 yyg->yy_last_accepting_cpos = yy_cp;
1566                 }
1567         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1568                 {
1569                 yy_current_state = (int) yy_def[yy_current_state];
1570                 if ( yy_current_state >= 165 )
1571                         yy_c = yy_meta[(unsigned int) yy_c];
1572                 }
1573         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1574         yy_is_jam = (yy_current_state == 164);
1575
1576         return yy_is_jam ? 0 : yy_current_state;
1577 }
1578
1579     static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
1580 {
1581         char *yy_cp;
1582     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1583
1584     yy_cp = yyg->yy_c_buf_p;
1585
1586         /* undo effects of setting up yytext */
1587         *yy_cp = yyg->yy_hold_char;
1588
1589         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1590                 { /* need to shift things up to make room */
1591                 /* +2 for EOB chars. */
1592                 int number_to_move = yyg->yy_n_chars + 2;
1593                 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1594                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1595                 char *source =
1596                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1597
1598                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1599                         *--dest = *--source;
1600
1601                 yy_cp += (int) (dest - source);
1602                 yy_bp += (int) (dest - source);
1603                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1604                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1605
1606                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1607                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1608                 }
1609
1610         *--yy_cp = (char) c;
1611
1612         yyg->yytext_ptr = yy_bp;
1613         yyg->yy_hold_char = *yy_cp;
1614         yyg->yy_c_buf_p = yy_cp;
1615 }
1616
1617 #ifndef YY_NO_INPUT
1618 #ifdef __cplusplus
1619     static int yyinput (yyscan_t yyscanner)
1620 #else
1621     static int input  (yyscan_t yyscanner)
1622 #endif
1623
1624 {
1625         int c;
1626     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1627
1628         *yyg->yy_c_buf_p = yyg->yy_hold_char;
1629
1630         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1631                 {
1632                 /* yy_c_buf_p now points to the character we want to return.
1633                  * If this occurs *before* the EOB characters, then it's a
1634                  * valid NUL; if not, then we've hit the end of the buffer.
1635                  */
1636                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1637                         /* This was really a NUL. */
1638                         *yyg->yy_c_buf_p = '\0';
1639
1640                 else
1641                         { /* need more input */
1642                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1643                         ++yyg->yy_c_buf_p;
1644
1645                         switch ( yy_get_next_buffer( yyscanner ) )
1646                                 {
1647                                 case EOB_ACT_LAST_MATCH:
1648                                         /* This happens because yy_g_n_b()
1649                                          * sees that we've accumulated a
1650                                          * token and flags that we need to
1651                                          * try matching the token before
1652                                          * proceeding.  But for input(),
1653                                          * there's no matching to consider.
1654                                          * So convert the EOB_ACT_LAST_MATCH
1655                                          * to EOB_ACT_END_OF_FILE.
1656                                          */
1657
1658                                         /* Reset buffer status. */
1659                                         cmDependsFortran_yyrestart(yyin ,yyscanner);
1660
1661                                         /*FALLTHROUGH*/
1662
1663                                 case EOB_ACT_END_OF_FILE:
1664                                         {
1665                                         if ( cmDependsFortran_yywrap(yyscanner ) )
1666                                                 return EOF;
1667
1668                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1669                                                 YY_NEW_FILE;
1670 #ifdef __cplusplus
1671                                         return yyinput(yyscanner);
1672 #else
1673                                         return input(yyscanner);
1674 #endif
1675                                         }
1676
1677                                 case EOB_ACT_CONTINUE_SCAN:
1678                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1679                                         break;
1680                                 }
1681                         }
1682                 }
1683
1684         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1685         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
1686         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1687
1688         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1689
1690         return c;
1691 }
1692 #endif  /* ifndef YY_NO_INPUT */
1693
1694 /** Immediately switch to a different input stream.
1695  * @param input_file A readable stream.
1696  * @param yyscanner The scanner object.
1697  * @note This function does not reset the start condition to @c INITIAL .
1698  */
1699     void cmDependsFortran_yyrestart  (FILE * input_file , yyscan_t yyscanner)
1700 {
1701     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1702
1703         if ( ! YY_CURRENT_BUFFER ){
1704         cmDependsFortran_yyensure_buffer_stack (yyscanner);
1705                 YY_CURRENT_BUFFER_LVALUE =
1706             cmDependsFortran_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1707         }
1708
1709         cmDependsFortran_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1710         cmDependsFortran_yy_load_buffer_state(yyscanner );
1711 }
1712
1713 /** Switch to a different input buffer.
1714  * @param new_buffer The new input buffer.
1715  * @param yyscanner The scanner object.
1716  */
1717     void cmDependsFortran_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
1718 {
1719     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1720
1721         /* TODO. We should be able to replace this entire function body
1722          * with
1723          *              cmDependsFortran_yypop_buffer_state();
1724          *              cmDependsFortran_yypush_buffer_state(new_buffer);
1725      */
1726         cmDependsFortran_yyensure_buffer_stack (yyscanner);
1727         if ( YY_CURRENT_BUFFER == new_buffer )
1728                 return;
1729
1730         if ( YY_CURRENT_BUFFER )
1731                 {
1732                 /* Flush out information for old buffer. */
1733                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1734                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1735                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1736                 }
1737
1738         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1739         cmDependsFortran_yy_load_buffer_state(yyscanner );
1740
1741         /* We don't actually know whether we did this switch during
1742          * EOF (cmDependsFortran_yywrap()) processing, but the only time this flag
1743          * is looked at is after cmDependsFortran_yywrap() is called, so it's safe
1744          * to go ahead and always set it.
1745          */
1746         yyg->yy_did_buffer_switch_on_eof = 1;
1747 }
1748
1749 static void cmDependsFortran_yy_load_buffer_state  (yyscan_t yyscanner)
1750 {
1751     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1752         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1753         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1754         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1755         yyg->yy_hold_char = *yyg->yy_c_buf_p;
1756 }
1757
1758 /** Allocate and initialize an input buffer state.
1759  * @param file A readable stream.
1760  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1761  * @param yyscanner The scanner object.
1762  * @return the allocated buffer state.
1763  */
1764     YY_BUFFER_STATE cmDependsFortran_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
1765 {
1766         YY_BUFFER_STATE b;
1767
1768         b = (YY_BUFFER_STATE) cmDependsFortran_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1769         if ( ! b )
1770                 YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_create_buffer()" );
1771
1772         b->yy_buf_size = size;
1773
1774         /* yy_ch_buf has to be 2 characters longer than the size given because
1775          * we need to put in 2 end-of-buffer characters.
1776          */
1777         b->yy_ch_buf = (char *) cmDependsFortran_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1778         if ( ! b->yy_ch_buf )
1779                 YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_create_buffer()" );
1780
1781         b->yy_is_our_buffer = 1;
1782
1783         cmDependsFortran_yy_init_buffer(b,file ,yyscanner);
1784
1785         return b;
1786 }
1787
1788 /** Destroy the buffer.
1789  * @param b a buffer created with cmDependsFortran_yy_create_buffer()
1790  * @param yyscanner The scanner object.
1791  */
1792     void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1793 {
1794     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1795
1796         if ( ! b )
1797                 return;
1798
1799         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1800                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1801
1802         if ( b->yy_is_our_buffer )
1803                 cmDependsFortran_yyfree((void *) b->yy_ch_buf ,yyscanner );
1804
1805         cmDependsFortran_yyfree((void *) b ,yyscanner );
1806 }
1807
1808 #ifndef __cplusplus
1809 extern int isatty (int );
1810 #endif /* __cplusplus */
1811
1812 /* Initializes or reinitializes a buffer.
1813  * This function is sometimes called more than once on the same buffer,
1814  * such as during a cmDependsFortran_yyrestart() or at EOF.
1815  */
1816     static void cmDependsFortran_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
1817
1818 {
1819         int oerrno = errno;
1820     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1821
1822         cmDependsFortran_yy_flush_buffer(b ,yyscanner);
1823
1824         b->yy_input_file = file;
1825         b->yy_fill_buffer = 1;
1826
1827     /* If b is the current buffer, then cmDependsFortran_yy_init_buffer was _probably_
1828      * called from cmDependsFortran_yyrestart() or through yy_get_next_buffer.
1829      * In that case, we don't want to reset the lineno or column.
1830      */
1831     if (b != YY_CURRENT_BUFFER){
1832         b->yy_bs_lineno = 1;
1833         b->yy_bs_column = 0;
1834     }
1835
1836         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1837
1838         errno = oerrno;
1839 }
1840
1841 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1842  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1843  * @param yyscanner The scanner object.
1844  */
1845     void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1846 {
1847     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1848         if ( ! b )
1849                 return;
1850
1851         b->yy_n_chars = 0;
1852
1853         /* We always need two end-of-buffer characters.  The first causes
1854          * a transition to the end-of-buffer state.  The second causes
1855          * a jam in that state.
1856          */
1857         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1858         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1859
1860         b->yy_buf_pos = &b->yy_ch_buf[0];
1861
1862         b->yy_at_bol = 1;
1863         b->yy_buffer_status = YY_BUFFER_NEW;
1864
1865         if ( b == YY_CURRENT_BUFFER )
1866                 cmDependsFortran_yy_load_buffer_state(yyscanner );
1867 }
1868
1869 /** Pushes the new state onto the stack. The new state becomes
1870  *  the current state. This function will allocate the stack
1871  *  if necessary.
1872  *  @param new_buffer The new state.
1873  *  @param yyscanner The scanner object.
1874  */
1875 void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1876 {
1877     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1878         if (new_buffer == NULL)
1879                 return;
1880
1881         cmDependsFortran_yyensure_buffer_stack(yyscanner);
1882
1883         /* This block is copied from cmDependsFortran_yy_switch_to_buffer. */
1884         if ( YY_CURRENT_BUFFER )
1885                 {
1886                 /* Flush out information for old buffer. */
1887                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1888                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1889                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1890                 }
1891
1892         /* Only push if top exists. Otherwise, replace top. */
1893         if (YY_CURRENT_BUFFER)
1894                 yyg->yy_buffer_stack_top++;
1895         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1896
1897         /* copied from cmDependsFortran_yy_switch_to_buffer. */
1898         cmDependsFortran_yy_load_buffer_state(yyscanner );
1899         yyg->yy_did_buffer_switch_on_eof = 1;
1900 }
1901
1902 /** Removes and deletes the top of the stack, if present.
1903  *  The next element becomes the new top.
1904  *  @param yyscanner The scanner object.
1905  */
1906 void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner)
1907 {
1908     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1909         if (!YY_CURRENT_BUFFER)
1910                 return;
1911
1912         cmDependsFortran_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1913         YY_CURRENT_BUFFER_LVALUE = NULL;
1914         if (yyg->yy_buffer_stack_top > 0)
1915                 --yyg->yy_buffer_stack_top;
1916
1917         if (YY_CURRENT_BUFFER) {
1918                 cmDependsFortran_yy_load_buffer_state(yyscanner );
1919                 yyg->yy_did_buffer_switch_on_eof = 1;
1920         }
1921 }
1922
1923 /* Allocates the stack if it does not exist.
1924  *  Guarantees space for at least one push.
1925  */
1926 static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
1927 {
1928         int num_to_alloc;
1929     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1930
1931         if (!yyg->yy_buffer_stack) {
1932
1933                 /* First allocation is just for 2 elements, since we don't know if this
1934                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1935                  * immediate realloc on the next call.
1936          */
1937                 num_to_alloc = 1;
1938                 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyalloc
1939                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1940                                                                 , yyscanner);
1941                 if ( ! yyg->yy_buffer_stack )
1942                         YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yyensure_buffer_stack()" );
1943
1944                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1945
1946                 yyg->yy_buffer_stack_max = num_to_alloc;
1947                 yyg->yy_buffer_stack_top = 0;
1948                 return;
1949         }
1950
1951         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1952
1953                 /* Increase the buffer to prepare for a possible push. */
1954                 int grow_size = 8 /* arbitrary grow size */;
1955
1956                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1957                 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyrealloc
1958                                                                 (yyg->yy_buffer_stack,
1959                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1960                                                                 , yyscanner);
1961                 if ( ! yyg->yy_buffer_stack )
1962                         YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yyensure_buffer_stack()" );
1963
1964                 /* zero only the new slots.*/
1965                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1966                 yyg->yy_buffer_stack_max = num_to_alloc;
1967         }
1968 }
1969
1970 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1971  * @param base the character buffer
1972  * @param size the size in bytes of the character buffer
1973  * @param yyscanner The scanner object.
1974  * @return the newly allocated buffer state object.
1975  */
1976 YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
1977 {
1978         YY_BUFFER_STATE b;
1979
1980         if ( size < 2 ||
1981              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1982              base[size-1] != YY_END_OF_BUFFER_CHAR )
1983                 /* They forgot to leave room for the EOB's. */
1984                 return 0;
1985
1986         b = (YY_BUFFER_STATE) cmDependsFortran_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1987         if ( ! b )
1988                 YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_scan_buffer()" );
1989
1990         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1991         b->yy_buf_pos = b->yy_ch_buf = base;
1992         b->yy_is_our_buffer = 0;
1993         b->yy_input_file = 0;
1994         b->yy_n_chars = b->yy_buf_size;
1995         b->yy_is_interactive = 0;
1996         b->yy_at_bol = 1;
1997         b->yy_fill_buffer = 0;
1998         b->yy_buffer_status = YY_BUFFER_NEW;
1999
2000         cmDependsFortran_yy_switch_to_buffer(b ,yyscanner );
2001
2002         return b;
2003 }
2004
2005 /** Setup the input buffer state to scan a string. The next call to cmDependsFortran_yylex() will
2006  * scan from a @e copy of @a str.
2007  * @param yystr a NUL-terminated string to scan
2008  * @param yyscanner The scanner object.
2009  * @return the newly allocated buffer state object.
2010  * @note If you want to scan bytes that may contain NUL values, then use
2011  *       cmDependsFortran_yy_scan_bytes() instead.
2012  */
2013 YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
2014 {
2015
2016         return cmDependsFortran_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
2017 }
2018
2019 /** Setup the input buffer state to scan the given bytes. The next call to cmDependsFortran_yylex() will
2020  * scan from a @e copy of @a bytes.
2021  * @param yybytes the byte buffer to scan
2022  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2023  * @param yyscanner The scanner object.
2024  * @return the newly allocated buffer state object.
2025  */
2026 YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
2027 {
2028         YY_BUFFER_STATE b;
2029         char *buf;
2030         yy_size_t n;
2031         int i;
2032
2033         /* Get memory for full buffer, including space for trailing EOB's. */
2034         n = _yybytes_len + 2;
2035         buf = (char *) cmDependsFortran_yyalloc(n ,yyscanner );
2036         if ( ! buf )
2037                 YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_scan_bytes()" );
2038
2039         for ( i = 0; i < _yybytes_len; ++i )
2040                 buf[i] = yybytes[i];
2041
2042         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2043
2044         b = cmDependsFortran_yy_scan_buffer(buf,n ,yyscanner);
2045         if ( ! b )
2046                 YY_FATAL_ERROR( "bad buffer in cmDependsFortran_yy_scan_bytes()" );
2047
2048         /* It's okay to grow etc. this buffer, and we should throw it
2049          * away when we're done.
2050          */
2051         b->yy_is_our_buffer = 1;
2052
2053         return b;
2054 }
2055
2056 #ifndef YY_EXIT_FAILURE
2057 #define YY_EXIT_FAILURE 2
2058 #endif
2059
2060 static void yy_fatal_error (yyconst char* msg , yyscan_t)
2061 {
2062         (void) fprintf( stderr, "%s\n", msg );
2063         exit( YY_EXIT_FAILURE );
2064 }
2065
2066 /* Redefine yyless() so it works in section 3 code. */
2067
2068 #undef yyless
2069 #define yyless(n) \
2070         do \
2071                 { \
2072                 /* Undo effects of setting up yytext. */ \
2073         int yyless_macro_arg = (n); \
2074         YY_LESS_LINENO(yyless_macro_arg);\
2075                 yytext[yyleng] = yyg->yy_hold_char; \
2076                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2077                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2078                 *yyg->yy_c_buf_p = '\0'; \
2079                 yyleng = yyless_macro_arg; \
2080                 } \
2081         while ( 0 )
2082
2083 /* Accessor  methods (get/set functions) to struct members. */
2084
2085 /** Get the user-defined data for this scanner.
2086  * @param yyscanner The scanner object.
2087  */
2088 YY_EXTRA_TYPE cmDependsFortran_yyget_extra  (yyscan_t yyscanner)
2089 {
2090     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2091     return yyextra;
2092 }
2093
2094 /** Get the current line number.
2095  * @param yyscanner The scanner object.
2096  */
2097 int cmDependsFortran_yyget_lineno  (yyscan_t yyscanner)
2098 {
2099     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2100
2101         if (! YY_CURRENT_BUFFER)
2102             return 0;
2103
2104     return yylineno;
2105 }
2106
2107 /** Get the current column number.
2108  * @param yyscanner The scanner object.
2109  */
2110 int cmDependsFortran_yyget_column  (yyscan_t yyscanner)
2111 {
2112     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2113
2114         if (! YY_CURRENT_BUFFER)
2115             return 0;
2116
2117     return yycolumn;
2118 }
2119
2120 /** Get the input stream.
2121  * @param yyscanner The scanner object.
2122  */
2123 FILE *cmDependsFortran_yyget_in  (yyscan_t yyscanner)
2124 {
2125     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2126     return yyin;
2127 }
2128
2129 /** Get the output stream.
2130  * @param yyscanner The scanner object.
2131  */
2132 FILE *cmDependsFortran_yyget_out  (yyscan_t yyscanner)
2133 {
2134     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2135     return yyout;
2136 }
2137
2138 /** Get the length of the current token.
2139  * @param yyscanner The scanner object.
2140  */
2141 int cmDependsFortran_yyget_leng  (yyscan_t yyscanner)
2142 {
2143     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2144     return yyleng;
2145 }
2146
2147 /** Get the current token.
2148  * @param yyscanner The scanner object.
2149  */
2150
2151 char *cmDependsFortran_yyget_text  (yyscan_t yyscanner)
2152 {
2153     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2154     return yytext;
2155 }
2156
2157 /** Set the user-defined data. This data is never touched by the scanner.
2158  * @param user_defined The data to be associated with this scanner.
2159  * @param yyscanner The scanner object.
2160  */
2161 void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2162 {
2163     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2164     yyextra = user_defined ;
2165 }
2166
2167 /** Set the current line number.
2168  * @param line_number
2169  * @param yyscanner The scanner object.
2170  */
2171 void cmDependsFortran_yyset_lineno (int  line_number , yyscan_t yyscanner)
2172 {
2173     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2174
2175         /* lineno is only valid if an input buffer exists. */
2176         if (! YY_CURRENT_BUFFER )
2177            yy_fatal_error( "cmDependsFortran_yyset_lineno called with no buffer" , yyscanner);
2178
2179     yylineno = line_number;
2180 }
2181
2182 /** Set the current column.
2183  * @param line_number
2184  * @param yyscanner The scanner object.
2185  */
2186 void cmDependsFortran_yyset_column (int  column_no , yyscan_t yyscanner)
2187 {
2188     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2189
2190         /* column is only valid if an input buffer exists. */
2191         if (! YY_CURRENT_BUFFER )
2192            yy_fatal_error( "cmDependsFortran_yyset_column called with no buffer" , yyscanner);
2193
2194     yycolumn = column_no;
2195 }
2196
2197 /** Set the input stream. This does not discard the current
2198  * input buffer.
2199  * @param in_str A readable stream.
2200  * @param yyscanner The scanner object.
2201  * @see cmDependsFortran_yy_switch_to_buffer
2202  */
2203 void cmDependsFortran_yyset_in (FILE *  in_str , yyscan_t yyscanner)
2204 {
2205     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2206     yyin = in_str ;
2207 }
2208
2209 void cmDependsFortran_yyset_out (FILE *  out_str , yyscan_t yyscanner)
2210 {
2211     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2212     yyout = out_str ;
2213 }
2214
2215 int cmDependsFortran_yyget_debug  (yyscan_t yyscanner)
2216 {
2217     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2218     return yy_flex_debug;
2219 }
2220
2221 void cmDependsFortran_yyset_debug (int  bdebug , yyscan_t yyscanner)
2222 {
2223     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2224     yy_flex_debug = bdebug ;
2225 }
2226
2227 /* Accessor methods for yylval and yylloc */
2228
2229 /* User-visible API */
2230
2231 /* cmDependsFortran_yylex_init is special because it creates the scanner itself, so it is
2232  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2233  * That's why we explicitly handle the declaration, instead of using our macros.
2234  */
2235
2236 int cmDependsFortran_yylex_init(yyscan_t* ptr_yy_globals)
2237
2238 {
2239     if (ptr_yy_globals == NULL){
2240         errno = EINVAL;
2241         return 1;
2242     }
2243
2244     *ptr_yy_globals = (yyscan_t) cmDependsFortran_yyalloc ( sizeof( struct yyguts_t ), NULL );
2245
2246     if (*ptr_yy_globals == NULL){
2247         errno = ENOMEM;
2248         return 1;
2249     }
2250
2251     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2252     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2253
2254     return yy_init_globals ( *ptr_yy_globals );
2255 }
2256
2257 /* cmDependsFortran_yylex_init_extra has the same functionality as cmDependsFortran_yylex_init, but follows the
2258  * convention of taking the scanner as the last argument. Note however, that
2259  * this is a *pointer* to a scanner, as it will be allocated by this call (and
2260  * is the reason, too, why this function also must handle its own declaration).
2261  * The user defined value in the first argument will be available to cmDependsFortran_yyalloc in
2262  * the yyextra field.
2263  */
2264
2265 int cmDependsFortran_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
2266
2267 {
2268     struct yyguts_t dummy_yyguts;
2269
2270     cmDependsFortran_yyset_extra (yy_user_defined, &dummy_yyguts);
2271
2272     if (ptr_yy_globals == NULL){
2273         errno = EINVAL;
2274         return 1;
2275     }
2276
2277     *ptr_yy_globals = (yyscan_t) cmDependsFortran_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2278
2279     if (*ptr_yy_globals == NULL){
2280         errno = ENOMEM;
2281         return 1;
2282     }
2283
2284     /* By setting to 0xAA, we expose bugs in
2285     yy_init_globals. Leave at 0x00 for releases. */
2286     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2287
2288     cmDependsFortran_yyset_extra (yy_user_defined, *ptr_yy_globals);
2289
2290     return yy_init_globals ( *ptr_yy_globals );
2291 }
2292
2293 static int yy_init_globals (yyscan_t yyscanner)
2294 {
2295     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2296     /* Initialization is the same as for the non-reentrant scanner.
2297      * This function is called from cmDependsFortran_yylex_destroy(), so don't allocate here.
2298      */
2299
2300     yyg->yy_buffer_stack = 0;
2301     yyg->yy_buffer_stack_top = 0;
2302     yyg->yy_buffer_stack_max = 0;
2303     yyg->yy_c_buf_p = (char *) 0;
2304     yyg->yy_init = 0;
2305     yyg->yy_start = 0;
2306
2307     yyg->yy_start_stack_ptr = 0;
2308     yyg->yy_start_stack_depth = 0;
2309     yyg->yy_start_stack =  NULL;
2310
2311 /* Defined in main.c */
2312 #ifdef YY_STDINIT
2313     yyin = stdin;
2314     yyout = stdout;
2315 #else
2316     yyin = (FILE *) 0;
2317     yyout = (FILE *) 0;
2318 #endif
2319
2320     /* For future reference: Set errno on error, since we are called by
2321      * cmDependsFortran_yylex_init()
2322      */
2323     return 0;
2324 }
2325
2326 /* cmDependsFortran_yylex_destroy is for both reentrant and non-reentrant scanners. */
2327 int cmDependsFortran_yylex_destroy  (yyscan_t yyscanner)
2328 {
2329     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2330
2331     /* Pop the buffer stack, destroying each element. */
2332         while(YY_CURRENT_BUFFER){
2333                 cmDependsFortran_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2334                 YY_CURRENT_BUFFER_LVALUE = NULL;
2335                 cmDependsFortran_yypop_buffer_state(yyscanner);
2336         }
2337
2338         /* Destroy the stack itself. */
2339         cmDependsFortran_yyfree(yyg->yy_buffer_stack ,yyscanner);
2340         yyg->yy_buffer_stack = NULL;
2341
2342     /* Destroy the start condition stack. */
2343         cmDependsFortran_yyfree(yyg->yy_start_stack ,yyscanner );
2344         yyg->yy_start_stack = NULL;
2345
2346     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2347      * cmDependsFortran_yylex() is called, initialization will occur. */
2348     yy_init_globals( yyscanner);
2349
2350     /* Destroy the main struct (reentrant only). */
2351     cmDependsFortran_yyfree ( yyscanner , yyscanner );
2352     return 0;
2353 }
2354
2355 /*
2356  * Internal utility routines.
2357  */
2358
2359 #ifndef yytext_ptr
2360 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2361 {
2362         int i;
2363         for ( i = 0; i < n; ++i )
2364                 s1[i] = s2[i];
2365 }
2366 #endif
2367
2368 #ifdef YY_NEED_STRLEN
2369 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2370 {
2371         int n;
2372         for ( n = 0; s[n]; ++n )
2373                 ;
2374
2375         return n;
2376 }
2377 #endif
2378
2379 void *cmDependsFortran_yyalloc (yy_size_t  size , yyscan_t)
2380 {
2381         return (void *) malloc( size );
2382 }
2383
2384 void *cmDependsFortran_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t)
2385 {
2386         /* The cast to (char *) in the following accommodates both
2387          * implementations that use char* generic pointers, and those
2388          * that use void* generic pointers.  It works with the latter
2389          * because both ANSI C and C++ allow castless assignment from
2390          * any pointer type to void*, and deal with argument conversions
2391          * as though doing an assignment.
2392          */
2393         return (void *) realloc( (char *) ptr, size );
2394 }
2395
2396 void cmDependsFortran_yyfree (void * ptr , yyscan_t)
2397 {
2398         free( (char *) ptr );   /* see cmDependsFortran_yyrealloc() for (char *) cast */
2399 }
2400
2401 #define YYTABLES_NAME "yytables"
2402
2403 #line 181 "cmDependsFortranLexer.in.l"
2404
2405
2406
2407 /*--------------------------------------------------------------------------*/
2408 YY_BUFFER_STATE cmDependsFortranLexer_GetCurrentBuffer(yyscan_t yyscanner)
2409 {
2410   /* Hack into the internal flex-generated scanner to get the buffer.  */
2411   struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2412   return YY_CURRENT_BUFFER;
2413 }
2414