Source/cmDependsFortranParser.cxx

   1 /* A Bison parser, made by GNU Bison 2.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free Software Foundation, Inc.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 /* As a special exception, you may create a larger work that contains
  24    part or all of the Bison parser skeleton and distribute that work
  25    under terms of your choice, so long as that work isn't itself a
  26    parser generator using the skeleton or a modified version thereof
  27    as a parser skeleton.  Alternatively, if you modify or redistribute
  28    the parser skeleton itself, you may (at your option) remove this
  29    special exception, which will cause the skeleton and the resulting
  30    Bison output files to be licensed under the GNU General Public
  31    License without this special exception.
  32
  33    This special exception was added by the Free Software Foundation in
  34    version 2.2 of Bison.  */
  35
  36 /* C LALR(1) parser skeleton written by Richard Stallman, by
  37    simplifying the original so-called "semantic" parser.  */
  38
  39 /* All symbols defined below should begin with yy or YY, to avoid
  40    infringing on user name space.  This should be done even for local
  41    variables, as they might otherwise be expanded by user macros.
  42    There are some unavoidable exceptions within include files to
  43    define necessary library symbols; they are noted "INFRINGES ON
  44    USER NAME SPACE" below.  */
  45
  46 /* Identify Bison output.  */
  47 #define YYBISON 1
  48
  49 /* Bison version.  */
  50 #define YYBISON_VERSION "2.3"
  51
  52 /* Skeleton name.  */
  53 #define YYSKELETON_NAME "yacc.c"
  54
  55 /* Pure parsers.  */
  56 #define YYPURE 1
  57
  58 /* Using locations.  */
  59 #define YYLSP_NEEDED 0
  60
  61 /* Substitute the variable and function names.  */
  62 #define yyparse cmDependsFortran_yyparse
  63 #define yylex   cmDependsFortran_yylex
  64 #define yyerror cmDependsFortran_yyerror
  65 #define yylval  cmDependsFortran_yylval
  66 #define yychar  cmDependsFortran_yychar
  67 #define yydebug cmDependsFortran_yydebug
  68 #define yynerrs cmDependsFortran_yynerrs
  69
  70
  71 /* Tokens.  */
  72 #ifndef YYTOKENTYPE
  73 # define YYTOKENTYPE
  74    /* Put the tokens into the symbol table, so that GDB and other debuggers
  75       know about them.  */
  76    enum yytokentype {
  77      EOSTMT = 258,
  78      ASSIGNMENT_OP = 259,
  79      GARBAGE = 260,
  80      CPP_INCLUDE = 261,
  81      F90PPR_INCLUDE = 262,
  82      COCO_INCLUDE = 263,
  83      F90PPR_DEFINE = 264,
  84      CPP_DEFINE = 265,
  85      F90PPR_UNDEF = 266,
  86      CPP_UNDEF = 267,
  87      CPP_IFDEF = 268,
  88      CPP_IFNDEF = 269,
  89      CPP_IF = 270,
  90      CPP_ELSE = 271,
  91      CPP_ELIF = 272,
  92      CPP_ENDIF = 273,
  93      F90PPR_IFDEF = 274,
  94      F90PPR_IFNDEF = 275,
  95      F90PPR_IF = 276,
  96      F90PPR_ELSE = 277,
  97      F90PPR_ELIF = 278,
  98      F90PPR_ENDIF = 279,
  99      COMMA = 280,
 100      DCOLON = 281,
 101      CPP_TOENDL = 282,
 102      UNTERMINATED_STRING = 283,
 103      STRING = 284,
 104      WORD = 285
 105    };
 106 #endif
 107 /* Tokens.  */
 108 #define EOSTMT 258
 109 #define ASSIGNMENT_OP 259
 110 #define GARBAGE 260
 111 #define CPP_INCLUDE 261
 112 #define F90PPR_INCLUDE 262
 113 #define COCO_INCLUDE 263
 114 #define F90PPR_DEFINE 264
 115 #define CPP_DEFINE 265
 116 #define F90PPR_UNDEF 266
 117 #define CPP_UNDEF 267
 118 #define CPP_IFDEF 268
 119 #define CPP_IFNDEF 269
 120 #define CPP_IF 270
 121 #define CPP_ELSE 271
 122 #define CPP_ELIF 272
 123 #define CPP_ENDIF 273
 124 #define F90PPR_IFDEF 274
 125 #define F90PPR_IFNDEF 275
 126 #define F90PPR_IF 276
 127 #define F90PPR_ELSE 277
 128 #define F90PPR_ELIF 278
 129 #define F90PPR_ENDIF 279
 130 #define COMMA 280
 131 #define DCOLON 281
 132 #define CPP_TOENDL 282
 133 #define UNTERMINATED_STRING 283
 134 #define STRING 284
 135 #define WORD 285
 136
 137
 138
 139
 140 /* Copy the first part of user declarations.  */
 141 #line 1 "cmDependsFortranParser.y"
 142
 143 /*=========================================================================
 144
 145   Program:   CMake - Cross-Platform Makefile Generator
 146   Module:    $RCSfile: cmDependsFortranParser.cxx,v $
 147   Language:  C++
 148   Date:      $Date: 2009-02-17 16:53:57 $
 149   Version:   $Revision: 1.19 $
 150
 151   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
 152   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 153
 154      This software is distributed WITHOUT ANY WARRANTY; without even
 155      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 156      PURPOSE.  See the above copyright notices for more information.
 157
 158 =========================================================================*/
 159 /*-------------------------------------------------------------------------
 160   Portions of this source have been derived from makedepf90 version 2.8.8,
 161
 162    Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
 163
 164   The code was originally distributed under the GPL but permission
 165   from the copyright holder has been obtained to distribute this
 166   derived work under the CMake license.
 167 -------------------------------------------------------------------------*/
 168
 169 /*
 170
 171 This file must be translated to C and modified to build everywhere.
 172
 173 Run bison like this:
 174
 175   bison --yacc --name-prefix=cmDependsFortran_yy
 176         --defines=cmDependsFortranParserTokens.h
 177          -ocmDependsFortranParser.cxx
 178           cmDependsFortranParser.y
 179
 180 Modify cmDependsFortranParser.cxx:
 181   - remove TABs
 182   - Remove the yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
 183 */
 184
 185 /*-------------------------------------------------------------------------*/
 186 #define cmDependsFortranParser_cxx
 187 #include "cmDependsFortranParser.h" /* Interface to parser object.  */
 188 #include "cmDependsFortranParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
 189
 190 /* Configure the parser to use a lexer object.  */
 191 #define YYPARSE_PARAM yyscanner
 192 #define YYLEX_PARAM yyscanner
 193 #define YYERROR_VERBOSE 1
 194 #define cmDependsFortran_yyerror(x) \
 195         cmDependsFortranError(yyscanner, x)
 196
 197 /* Forward declare the lexer entry point.  */
 198 YY_DECL;
 199
 200 /* Helper function to forward error callback.  */
 201 static void cmDependsFortranError(yyscan_t yyscanner, const char* message)
 202 {
 203   cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
 204   cmDependsFortranParser_Error(parser, message);
 205 }
 206
 207 static char charmap[] = {
 208     '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
 209     '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
 210     '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
 211     '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
 212     '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
 213     '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
 214     '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
 215     '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
 216     '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
 217     '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
 218     '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
 219     '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
 220     '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
 221     '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
 222     '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
 223     '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
 224     '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
 225     '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
 226     '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
 227     '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
 228     '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
 229     '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
 230     '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
 231     '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
 232     '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
 233     '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
 234     '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
 235     '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
 236     '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
 237     '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
 238     '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
 239     '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377'
 240 };
 241
 242 inline int strcasecmpCM(const char *s1, const char *s2)
 243 {
 244   const char *cm = charmap;
 245   unsigned char const* us1 = reinterpret_cast<unsigned char const*>(s1);
 246   unsigned char const* us2 = reinterpret_cast<unsigned char const*>(s2);
 247
 248   while(cm[*us1] == cm[*us2++])
 249     if(*us1++ == '\0')
 250       {
 251       return(0);
 252       }
 253   return(cm[*us1] - cm[*--us2]);
 254 }
 255
 256 static bool cmDependsFortranParserIsKeyword(const char* word,
 257                                             const char* keyword)
 258 {
 259   return strcasecmpCM(word, keyword) == 0;
 260 }
 261
 262 /* Disable some warnings in the generated code.  */
 263 #ifdef __BORLANDC__
 264 # pragma warn -8004 /* Variable assigned a value that is not used.  */
 265 # pragma warn -8008 /* condition always returns true */
 266 # pragma warn -8060 /* possibly incorrect assignment */
 267 # pragma warn -8066 /* unreachable code */
 268 #endif
 269 #ifdef _MSC_VER
 270 # pragma warning (disable: 4102) /* Unused goto label.  */
 271 # pragma warning (disable: 4065) /* Switch contains default but no case. */
 272 # pragma warning (disable: 4701) /* Local variable may not be initialized.  */
 273 # pragma warning (disable: 4702) /* Unreachable code.  */
 274 # pragma warning (disable: 4127) /* Conditional expression is constant.  */
 275 # pragma warning (disable: 4244) /* Conversion to smaller type, data loss. */
 276 #endif
 277
 278
 279 /* Enabling traces.  */
 280 #ifndef YYDEBUG
 281 # define YYDEBUG 0
 282 #endif
 283
 284 /* Enabling verbose error messages.  */
 285 #ifdef YYERROR_VERBOSE
 286 # undef YYERROR_VERBOSE
 287 # define YYERROR_VERBOSE 1
 288 #else
 289 # define YYERROR_VERBOSE 0
 290 #endif
 291
 292 /* Enabling the token table.  */
 293 #ifndef YYTOKEN_TABLE
 294 # define YYTOKEN_TABLE 0
 295 #endif
 296
 297 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 298 typedef union YYSTYPE
 299 #line 141 "cmDependsFortranParser.y"
 300 {
 301   char* string;
 302 }
 303 /* Line 187 of yacc.c.  */
 304 #line 305 "cmDependsFortranParser.cxx"
 305         YYSTYPE;
 306 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 307 # define YYSTYPE_IS_DECLARED 1
 308 # define YYSTYPE_IS_TRIVIAL 1
 309 #endif
 310
 311
 312
 313 /* Copy the second part of user declarations.  */
 314
 315
 316 /* Line 216 of yacc.c.  */
 317 #line 318 "cmDependsFortranParser.cxx"
 318
 319 #ifdef short
 320 # undef short
 321 #endif
 322
 323 #ifdef YYTYPE_UINT8
 324 typedef YYTYPE_UINT8 yytype_uint8;
 325 #else
 326 typedef unsigned char yytype_uint8;
 327 #endif
 328
 329 #ifdef YYTYPE_INT8
 330 typedef YYTYPE_INT8 yytype_int8;
 331 #elif (defined __STDC__ || defined __C99__FUNC__ \
 332      || defined __cplusplus || defined _MSC_VER)
 333 typedef signed char yytype_int8;
 334 #else
 335 typedef short int yytype_int8;
 336 #endif
 337
 338 #ifdef YYTYPE_UINT16
 339 typedef YYTYPE_UINT16 yytype_uint16;
 340 #else
 341 typedef unsigned short int yytype_uint16;
 342 #endif
 343
 344 #ifdef YYTYPE_INT16
 345 typedef YYTYPE_INT16 yytype_int16;
 346 #else
 347 typedef short int yytype_int16;
 348 #endif
 349
 350 #ifndef YYSIZE_T
 351 # ifdef __SIZE_TYPE__
 352 #  define YYSIZE_T __SIZE_TYPE__
 353 # elif defined size_t
 354 #  define YYSIZE_T size_t
 355 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 356      || defined __cplusplus || defined _MSC_VER)
 357 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 358 #  define YYSIZE_T size_t
 359 # else
 360 #  define YYSIZE_T unsigned int
 361 # endif
 362 #endif
 363
 364 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 365
 366 #ifndef YY_
 367 # if YYENABLE_NLS
 368 #  if ENABLE_NLS
 369 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 370 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 371 #  endif
 372 # endif
 373 # ifndef YY_
 374 #  define YY_(msgid) msgid
 375 # endif
 376 #endif
 377
 378 /* Suppress unused-variable warnings by "using" E.  */
 379 #if ! defined lint || defined __GNUC__
 380 # define YYUSE(e) ((void) (e))
 381 #else
 382 # define YYUSE(e) /* empty */
 383 #endif
 384
 385 /* Identity function, used to suppress warnings about constant conditions.  */
 386 #ifndef lint
 387 # define YYID(n) (n)
 388 #else
 389 #if (defined __STDC__ || defined __C99__FUNC__ \
 390      || defined __cplusplus || defined _MSC_VER)
 391 static int
 392 YYID (int i)
 393 #else
 394 static int
 395 YYID (i)
 396     int i;
 397 #endif
 398 {
 399   return i;
 400 }
 401 #endif
 402
 403 #if ! defined yyoverflow || YYERROR_VERBOSE
 404
 405 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 406
 407 # ifdef YYSTACK_USE_ALLOCA
 408 #  if YYSTACK_USE_ALLOCA
 409 #   ifdef __GNUC__
 410 #    define YYSTACK_ALLOC __builtin_alloca
 411 #   elif defined __BUILTIN_VA_ARG_INCR
 412 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 413 #   elif defined _AIX
 414 #    define YYSTACK_ALLOC __alloca
 415 #   elif defined _MSC_VER
 416 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 417 #    define alloca _alloca
 418 #   else
 419 #    define YYSTACK_ALLOC alloca
 420 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 421      || defined __cplusplus || defined _MSC_VER)
 422 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 423 #     ifndef _STDLIB_H
 424 #      define _STDLIB_H 1
 425 #     endif
 426 #    endif
 427 #   endif
 428 #  endif
 429 # endif
 430
 431 # ifdef YYSTACK_ALLOC
 432    /* Pacify GCC's `empty if-body' warning.  */
 433 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 434 #  ifndef YYSTACK_ALLOC_MAXIMUM
 435     /* The OS might guarantee only one guard page at the bottom of the stack,
 436        and a page size can be as small as 4096 bytes.  So we cannot safely
 437        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 438        to allow for a few compiler-allocated temporary stack slots.  */
 439 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 440 #  endif
 441 # else
 442 #  define YYSTACK_ALLOC YYMALLOC
 443 #  define YYSTACK_FREE YYFREE
 444 #  ifndef YYSTACK_ALLOC_MAXIMUM
 445 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 446 #  endif
 447 #  if (defined __cplusplus && ! defined _STDLIB_H \
 448        && ! ((defined YYMALLOC || defined malloc) \
 449              && (defined YYFREE || defined free)))
 450 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 451 #   ifndef _STDLIB_H
 452 #    define _STDLIB_H 1
 453 #   endif
 454 #  endif
 455 #  ifndef YYMALLOC
 456 #   define YYMALLOC malloc
 457 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 458      || defined __cplusplus || defined _MSC_VER)
 459 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 460 #   endif
 461 #  endif
 462 #  ifndef YYFREE
 463 #   define YYFREE free
 464 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 465      || defined __cplusplus || defined _MSC_VER)
 466 void free (void *); /* INFRINGES ON USER NAME SPACE */
 467 #   endif
 468 #  endif
 469 # endif
 470 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 471
 472
 473 #if (! defined yyoverflow \
 474      && (! defined __cplusplus \
 475          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 476
 477 /* A type that is properly aligned for any stack member.  */
 478 union yyalloc
 479 {
 480   yytype_int16 yyss;
 481   YYSTYPE yyvs;
 482   };
 483
 484 /* The size of the maximum gap between one aligned stack and the next.  */
 485 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 486
 487 /* The size of an array large to enough to hold all stacks, each with
 488    N elements.  */
 489 # define YYSTACK_BYTES(N) \
 490      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 491       + YYSTACK_GAP_MAXIMUM)
 492
 493 /* Copy COUNT objects from FROM to TO.  The source and destination do
 494    not overlap.  */
 495 # ifndef YYCOPY
 496 #  if defined __GNUC__ && 1 < __GNUC__
 497 #   define YYCOPY(To, From, Count) \
 498       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 499 #  else
 500 #   define YYCOPY(To, From, Count)              \
 501       do                                        \
 502         {                                       \
 503           YYSIZE_T yyi;                         \
 504           for (yyi = 0; yyi < (Count); yyi++)   \
 505             (To)[yyi] = (From)[yyi];            \
 506         }                                       \
 507       while (YYID (0))
 508 #  endif
 509 # endif
 510
 511 /* Relocate STACK from its old location to the new one.  The
 512    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 513    elements in the stack, and YYPTR gives the new location of the
 514    stack.  Advance YYPTR to a properly aligned location for the next
 515    stack.  */
 516 # define YYSTACK_RELOCATE(Stack)                                        \
 517     do                                                                  \
 518       {                                                                 \
 519         YYSIZE_T yynewbytes;                                            \
 520         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 521         Stack = &yyptr->Stack;                                          \
 522         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 523         yyptr += yynewbytes / sizeof (*yyptr);                          \
 524       }                                                                 \
 525     while (YYID (0))
 526
 527 #endif
 528
 529 /* YYFINAL -- State number of the termination state.  */
 530 #define YYFINAL  2
 531 /* YYLAST -- Last index in YYTABLE.  */
 532 #define YYLAST   271
 533
 534 /* YYNTOKENS -- Number of terminals.  */
 535 #define YYNTOKENS  31
 536 /* YYNNTS -- Number of nonterminals.  */
 537 #define YYNNTS  16
 538 /* YYNRULES -- Number of rules.  */
 539 #define YYNRULES  52
 540 /* YYNRULES -- Number of states.  */
 541 #define YYNSTATES  94
 542
 543 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 544 #define YYUNDEFTOK  2
 545 #define YYMAXUTOK   285
 546
 547 #define YYTRANSLATE(YYX)                                                \
 548   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 549
 550 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 551 static const yytype_uint8 yytranslate[] =
 552 {
 553        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 554        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 555        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 556        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 557        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 558        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 559        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 560        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 561        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 562        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 563        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 564        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 565        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 566        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 567        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 568        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 569        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 570        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 571        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 573        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 574        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 576        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 578        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 579        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 580       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 581       25,    26,    27,    28,    29,    30
 582 };
 583
 584 #if YYDEBUG
 585 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 586    YYRHS.  */
 587 static const yytype_uint8 yyprhs[] =
 588 {
 589        0,     0,     3,     4,     7,     9,    11,    16,    19,    24,
 590       30,    38,    43,    48,    53,    58,    63,    68,    72,    76,
 591       80,    84,    89,    93,    95,    97,    99,   101,   103,   105,
 592      107,   109,   111,   113,   115,   117,   119,   121,   123,   125,
 593      127,   129,   131,   133,   135,   136,   139,   141,   143,   145,
 594      147,   149,   151
 595 };
 596
 597 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 598 static const yytype_int8 yyrhs[] =
 599 {
 600       32,     0,    -1,    -1,    32,    33,    -1,    35,    -1,    34,
 601       -1,    30,     4,    45,     3,    -1,    30,     3,    -1,    30,
 602       30,    45,     3,    -1,    30,    26,    30,    45,     3,    -1,
 603       30,    25,    30,    26,    30,    45,     3,    -1,    30,    29,
 604       45,     3,    -1,    36,    29,    45,     3,    -1,    37,    30,
 605       45,     3,    -1,    38,    30,    45,     3,    -1,    39,    30,
 606       45,     3,    -1,    40,    30,    45,     3,    -1,    41,    45,
 607        3,    -1,    42,    45,     3,    -1,    43,    45,     3,    -1,
 608       44,    45,     3,    -1,    30,     5,    45,     3,    -1,     5,
 609       45,     3,    -1,     3,    -1,     1,    -1,     6,    -1,     7,
 610       -1,     8,    -1,    10,    -1,     9,    -1,    12,    -1,    11,
 611       -1,    13,    -1,    19,    -1,    14,    -1,    20,    -1,    15,
 612       -1,    21,    -1,    17,    -1,    23,    -1,    16,    -1,    22,
 613       -1,    18,    -1,    24,    -1,    -1,    45,    46,    -1,    30,
 614       -1,    29,    -1,     5,    -1,     4,    -1,    26,    -1,    25,
 615       -1,    28,    -1
 616 };
 617
 618 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 619 static const yytype_uint16 yyrline[] =
 620 {
 621        0,   162,   162,   162,   164,   164,   166,   172,   182,   212,
 622      223,   236,   247,   254,   260,   266,   272,   278,   283,   288,
 623      293,   298,   302,   303,   304,   309,   309,   309,   310,   310,
 624      311,   311,   312,   312,   313,   313,   314,   314,   315,   315,
 625      316,   316,   317,   317,   318,   318,   321,   322,   323,   324,
 626      325,   326,   327
 627 };
 628 #endif
 629
 630 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 631 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 632    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 633 static const char *const yytname[] =
 634 {
 635   "$end", "error", "$undefined", "EOSTMT", "ASSIGNMENT_OP", "GARBAGE",
 636   "CPP_INCLUDE", "F90PPR_INCLUDE", "COCO_INCLUDE", "F90PPR_DEFINE",
 637   "CPP_DEFINE", "F90PPR_UNDEF", "CPP_UNDEF", "CPP_IFDEF", "CPP_IFNDEF",
 638   "CPP_IF", "CPP_ELSE", "CPP_ELIF", "CPP_ENDIF", "F90PPR_IFDEF",
 639   "F90PPR_IFNDEF", "F90PPR_IF", "F90PPR_ELSE", "F90PPR_ELIF",
 640   "F90PPR_ENDIF", "COMMA", "DCOLON", "CPP_TOENDL", "UNTERMINATED_STRING",
 641   "STRING", "WORD", "$accept", "code", "stmt", "assignment_stmt",
 642   "keyword_stmt", "include", "define", "undef", "ifdef", "ifndef", "if",
 643   "elif", "else", "endif", "other", "misc_code", 0
 644 };
 645 #endif
 646
 647 # ifdef YYPRINT
 648 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 649    token YYLEX-NUM.  */
 650 static const yytype_uint16 yytoknum[] =
 651 {
 652        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 653      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 654      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
 655      285
 656 };
 657 # endif
 658
 659 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 660 static const yytype_uint8 yyr1[] =
 661 {
 662        0,    31,    32,    32,    33,    33,    34,    35,    35,    35,
 663       35,    35,    35,    35,    35,    35,    35,    35,    35,    35,
 664       35,    35,    35,    35,    35,    36,    36,    36,    37,    37,
 665       38,    38,    39,    39,    40,    40,    41,    41,    42,    42,
 666       43,    43,    44,    44,    45,    45,    46,    46,    46,    46,
 667       46,    46,    46
 668 };
 669
 670 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 671 static const yytype_uint8 yyr2[] =
 672 {
 673        0,     2,     0,     2,     1,     1,     4,     2,     4,     5,
 674        7,     4,     4,     4,     4,     4,     4,     3,     3,     3,
 675        3,     4,     3,     1,     1,     1,     1,     1,     1,     1,
 676        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 677        1,     1,     1,     1,     0,     2,     1,     1,     1,     1,
 678        1,     1,     1
 679 };
 680
 681 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 682    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 683    means the default is an error.  */
 684 static const yytype_uint8 yydefact[] =
 685 {
 686        2,     0,     1,    24,    23,    44,    25,    26,    27,    29,
 687       28,    31,    30,    32,    34,    36,    40,    38,    42,    33,
 688       35,    37,    41,    39,    43,     0,     3,     5,     4,     0,
 689        0,     0,     0,     0,    44,    44,    44,    44,     0,     7,
 690       44,    44,     0,     0,    44,    44,    44,    44,    44,    44,
 691       44,     0,     0,     0,     0,    22,    49,    48,    51,    50,
 692       52,    47,    46,    45,     0,     0,     0,    44,     0,     0,
 693        0,     0,     0,     0,     0,    17,    18,    19,    20,     6,
 694       21,     0,     0,    11,     8,    12,    13,    14,    15,    16,
 695       44,     9,     0,    10
 696 };
 697
 698 /* YYDEFGOTO[NTERM-NUM].  */
 699 static const yytype_int8 yydefgoto[] =
 700 {
 701       -1,     1,    26,    27,    28,    29,    30,    31,    32,    33,
 702       34,    35,    36,    37,    38,    63
 703 };
 704
 705 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 706    STATE-NUM.  */
 707 #define YYPACT_NINF -35
 708 static const yytype_int16 yypact[] =
 709 {
 710      -35,    29,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
 711      -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
 712      -35,   -35,   -35,   -35,   -35,   241,   -35,   -35,   -35,   -25,
 713      -22,   -21,   -13,   -12,   -35,   -35,   -35,   -35,    57,   -35,
 714      -35,   -35,   -11,   -10,   -35,   -35,   -35,   -35,   -35,   -35,
 715      -35,    63,    69,    75,   103,   -35,   -35,   -35,   -35,   -35,
 716      -35,   -35,   -35,   -35,   109,   115,    -5,   -35,   121,   149,
 717      155,   161,   167,   195,   201,   -35,   -35,   -35,   -35,   -35,
 718      -35,    -8,   207,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
 719      -35,   -35,   213,   -35
 720 };
 721
 722 /* YYPGOTO[NTERM-NUM].  */
 723 static const yytype_int8 yypgoto[] =
 724 {
 725      -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
 726      -35,   -35,   -35,   -35,   -34,   -35
 727 };
 728
 729 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 730    positive, shift that token.  If negative, reduce the rule which
 731    number is the opposite.  If zero, do what YYDEFACT says.
 732    If YYTABLE_NINF, syntax error.  */
 733 #define YYTABLE_NINF -1
 734 static const yytype_uint8 yytable[] =
 735 {
 736       51,    52,    53,    54,    46,     0,    64,    65,    47,    48,
 737       68,    69,    70,    71,    72,    73,    74,    49,    50,    66,
 738       67,    81,    90,     0,     0,     0,     0,     0,     0,     2,
 739        3,     0,     4,    82,     5,     6,     7,     8,     9,    10,
 740       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 741       21,    22,    23,    24,     0,     0,    92,     0,     0,    25,
 742       55,    56,    57,     0,     0,     0,    75,    56,    57,     0,
 743        0,     0,    76,    56,    57,     0,     0,     0,    77,    56,
 744       57,     0,    58,    59,     0,    60,    61,    62,    58,    59,
 745        0,    60,    61,    62,    58,    59,     0,    60,    61,    62,
 746       58,    59,     0,    60,    61,    62,    78,    56,    57,     0,
 747        0,     0,    79,    56,    57,     0,     0,     0,    80,    56,
 748       57,     0,     0,     0,    83,    56,    57,     0,    58,    59,
 749        0,    60,    61,    62,    58,    59,     0,    60,    61,    62,
 750       58,    59,     0,    60,    61,    62,    58,    59,     0,    60,
 751       61,    62,    84,    56,    57,     0,     0,     0,    85,    56,
 752       57,     0,     0,     0,    86,    56,    57,     0,     0,     0,
 753       87,    56,    57,     0,    58,    59,     0,    60,    61,    62,
 754       58,    59,     0,    60,    61,    62,    58,    59,     0,    60,
 755       61,    62,    58,    59,     0,    60,    61,    62,    88,    56,
 756       57,     0,     0,     0,    89,    56,    57,     0,     0,     0,
 757       91,    56,    57,     0,     0,     0,    93,    56,    57,     0,
 758       58,    59,     0,    60,    61,    62,    58,    59,     0,    60,
 759       61,    62,    58,    59,     0,    60,    61,    62,    58,    59,
 760        0,    60,    61,    62,    39,    40,    41,     0,     0,     0,
 761        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 762        0,     0,     0,     0,     0,     0,    42,    43,     0,     0,
 763       44,    45
 764 };
 765
 766 static const yytype_int8 yycheck[] =
 767 {
 768       34,    35,    36,    37,    29,    -1,    40,    41,    30,    30,
 769       44,    45,    46,    47,    48,    49,    50,    30,    30,    30,
 770       30,    26,    30,    -1,    -1,    -1,    -1,    -1,    -1,     0,
 771        1,    -1,     3,    67,     5,     6,     7,     8,     9,    10,
 772       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 773       21,    22,    23,    24,    -1,    -1,    90,    -1,    -1,    30,
 774        3,     4,     5,    -1,    -1,    -1,     3,     4,     5,    -1,
 775       -1,    -1,     3,     4,     5,    -1,    -1,    -1,     3,     4,
 776        5,    -1,    25,    26,    -1,    28,    29,    30,    25,    26,
 777       -1,    28,    29,    30,    25,    26,    -1,    28,    29,    30,
 778       25,    26,    -1,    28,    29,    30,     3,     4,     5,    -1,
 779       -1,    -1,     3,     4,     5,    -1,    -1,    -1,     3,     4,
 780        5,    -1,    -1,    -1,     3,     4,     5,    -1,    25,    26,
 781       -1,    28,    29,    30,    25,    26,    -1,    28,    29,    30,
 782       25,    26,    -1,    28,    29,    30,    25,    26,    -1,    28,
 783       29,    30,     3,     4,     5,    -1,    -1,    -1,     3,     4,
 784        5,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,
 785        3,     4,     5,    -1,    25,    26,    -1,    28,    29,    30,
 786       25,    26,    -1,    28,    29,    30,    25,    26,    -1,    28,
 787       29,    30,    25,    26,    -1,    28,    29,    30,     3,     4,
 788        5,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,
 789        3,     4,     5,    -1,    -1,    -1,     3,     4,     5,    -1,
 790       25,    26,    -1,    28,    29,    30,    25,    26,    -1,    28,
 791       29,    30,    25,    26,    -1,    28,    29,    30,    25,    26,
 792       -1,    28,    29,    30,     3,     4,     5,    -1,    -1,    -1,
 793       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 794       -1,    -1,    -1,    -1,    -1,    -1,    25,    26,    -1,    -1,
 795       29,    30
 796 };
 797
 798 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 799    symbol of state STATE-NUM.  */
 800 static const yytype_uint8 yystos[] =
 801 {
 802        0,    32,     0,     1,     3,     5,     6,     7,     8,     9,
 803       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 804       20,    21,    22,    23,    24,    30,    33,    34,    35,    36,
 805       37,    38,    39,    40,    41,    42,    43,    44,    45,     3,
 806        4,     5,    25,    26,    29,    30,    29,    30,    30,    30,
 807       30,    45,    45,    45,    45,     3,     4,     5,    25,    26,
 808       28,    29,    30,    46,    45,    45,    30,    30,    45,    45,
 809       45,    45,    45,    45,    45,     3,     3,     3,     3,     3,
 810        3,    26,    45,     3,     3,     3,     3,     3,     3,     3,
 811       30,     3,    45,     3
 812 };
 813
 814 #define yyerrok         (yyerrstatus = 0)
 815 #define yyclearin       (yychar = YYEMPTY)
 816 #define YYEMPTY         (-2)
 817 #define YYEOF           0
 818
 819 #define YYACCEPT        goto yyacceptlab
 820 #define YYABORT         goto yyabortlab
 821 #define YYERROR         goto yyerrorlab
 822
 823
 824 /* Like YYERROR except do call yyerror.  This remains here temporarily
 825    to ease the transition to the new meaning of YYERROR, for GCC.
 826    Once GCC version 2 has supplanted version 1, this can go.  */
 827
 828 #define YYFAIL          goto yyerrlab
 829
 830 #define YYRECOVERING()  (!!yyerrstatus)
 831
 832 #define YYBACKUP(Token, Value)                                  \
 833 do                                                              \
 834   if (yychar == YYEMPTY && yylen == 1)                          \
 835     {                                                           \
 836       yychar = (Token);                                         \
 837       yylval = (Value);                                         \
 838       yytoken = YYTRANSLATE (yychar);                           \
 839       YYPOPSTACK (1);                                           \
 840       goto yybackup;                                            \
 841     }                                                           \
 842   else                                                          \
 843     {                                                           \
 844       yyerror (YY_("syntax error: cannot back up")); \
 845       YYERROR;                                                  \
 846     }                                                           \
 847 while (YYID (0))
 848
 849
 850 #define YYTERROR        1
 851 #define YYERRCODE       256
 852
 853
 854 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 855    If N is 0, then set CURRENT to the empty location which ends
 856    the previous symbol: RHS[0] (always defined).  */
 857
 858 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 859 #ifndef YYLLOC_DEFAULT
 860 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 861     do                                                                  \
 862       if (YYID (N))                                                    \
 863         {                                                               \
 864           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 865           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 866           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 867           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 868         }                                                               \
 869       else                                                              \
 870         {                                                               \
 871           (Current).first_line   = (Current).last_line   =              \
 872             YYRHSLOC (Rhs, 0).last_line;                                \
 873           (Current).first_column = (Current).last_column =              \
 874             YYRHSLOC (Rhs, 0).last_column;                              \
 875         }                                                               \
 876     while (YYID (0))
 877 #endif
 878
 879
 880 /* YY_LOCATION_PRINT -- Print the location on the stream.
 881    This macro was not mandated originally: define only if we know
 882    we won't break user code: when these are the locations we know.  */
 883
 884 #ifndef YY_LOCATION_PRINT
 885 # if YYLTYPE_IS_TRIVIAL
 886 #  define YY_LOCATION_PRINT(File, Loc)                  \
 887      fprintf (File, "%d.%d-%d.%d",                      \
 888               (Loc).first_line, (Loc).first_column,     \
 889               (Loc).last_line,  (Loc).last_column)
 890 # else
 891 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 892 # endif
 893 #endif
 894
 895
 896 /* YYLEX -- calling `yylex' with the right arguments.  */
 897
 898 #ifdef YYLEX_PARAM
 899 # define YYLEX yylex (&yylval, YYLEX_PARAM)
 900 #else
 901 # define YYLEX yylex (&yylval)
 902 #endif
 903
 904 /* Enable debugging if requested.  */
 905 #if YYDEBUG
 906
 907 # ifndef YYFPRINTF
 908 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 909 #  define YYFPRINTF fprintf
 910 # endif
 911
 912 # define YYDPRINTF(Args)                        \
 913 do {                                            \
 914   if (yydebug)                                  \
 915     YYFPRINTF Args;                             \
 916 } while (YYID (0))
 917
 918 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 919 do {                                                                      \
 920   if (yydebug)                                                            \
 921     {                                                                     \
 922       YYFPRINTF (stderr, "%s ", Title);                                   \
 923       yy_symbol_print (stderr,                                            \
 924                   Type, Value); \
 925       YYFPRINTF (stderr, "\n");                                           \
 926     }                                                                     \
 927 } while (YYID (0))
 928
 929
 930 /*--------------------------------.
 931 | Print this symbol on YYOUTPUT.  |
 932 `--------------------------------*/
 933
 934 /*ARGSUSED*/
 935 #if (defined __STDC__ || defined __C99__FUNC__ \
 936      || defined __cplusplus || defined _MSC_VER)
 937 static void
 938 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 939 #else
 940 static void
 941 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 942     FILE *yyoutput;
 943     int yytype;
 944     YYSTYPE const * const yyvaluep;
 945 #endif
 946 {
 947   if (!yyvaluep)
 948     return;
 949 # ifdef YYPRINT
 950   if (yytype < YYNTOKENS)
 951     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 952 # else
 953   YYUSE (yyoutput);
 954 # endif
 955   switch (yytype)
 956     {
 957       default:
 958         break;
 959     }
 960 }
 961
 962
 963 /*--------------------------------.
 964 | Print this symbol on YYOUTPUT.  |
 965 `--------------------------------*/
 966
 967 #if (defined __STDC__ || defined __C99__FUNC__ \
 968      || defined __cplusplus || defined _MSC_VER)
 969 static void
 970 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 971 #else
 972 static void
 973 yy_symbol_print (yyoutput, yytype, yyvaluep)
 974     FILE *yyoutput;
 975     int yytype;
 976     YYSTYPE const * const yyvaluep;
 977 #endif
 978 {
 979   if (yytype < YYNTOKENS)
 980     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 981   else
 982     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 983
 984   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
 985   YYFPRINTF (yyoutput, ")");
 986 }
 987
 988 /*------------------------------------------------------------------.
 989 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 990 | TOP (included).                                                   |
 991 `------------------------------------------------------------------*/
 992
 993 #if (defined __STDC__ || defined __C99__FUNC__ \
 994      || defined __cplusplus || defined _MSC_VER)
 995 static void
 996 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 997 #else
 998 static void
 999 yy_stack_print (bottom, top)
1000     yytype_int16 *bottom;
1001     yytype_int16 *top;
1002 #endif
1003 {
1004   YYFPRINTF (stderr, "Stack now");
1005   for (; bottom <= top; ++bottom)
1006     YYFPRINTF (stderr, " %d", *bottom);
1007   YYFPRINTF (stderr, "\n");
1008 }
1009
1010 # define YY_STACK_PRINT(Bottom, Top)                            \
1011 do {                                                            \
1012   if (yydebug)                                                  \
1013     yy_stack_print ((Bottom), (Top));                           \
1014 } while (YYID (0))
1015
1016
1017 /*------------------------------------------------.
1018 | Report that the YYRULE is going to be reduced.  |
1019 `------------------------------------------------*/
1020
1021 #if (defined __STDC__ || defined __C99__FUNC__ \
1022      || defined __cplusplus || defined _MSC_VER)
1023 static void
1024 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1025 #else
1026 static void
1027 yy_reduce_print (yyvsp, yyrule)
1028     YYSTYPE *yyvsp;
1029     int yyrule;
1030 #endif
1031 {
1032   int yynrhs = yyr2[yyrule];
1033   int yyi;
1034   unsigned long int yylno = yyrline[yyrule];
1035   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1036              yyrule - 1, yylno);
1037   /* The symbols being reduced.  */
1038   for (yyi = 0; yyi < yynrhs; yyi++)
1039     {
1040       fprintf (stderr, "   $%d = ", yyi + 1);
1041       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1042                        &(yyvsp[(yyi + 1) - (yynrhs)])
1043                                        );
1044       fprintf (stderr, "\n");
1045     }
1046 }
1047
1048 # define YY_REDUCE_PRINT(Rule)          \
1049 do {                                    \
1050   if (yydebug)                          \
1051     yy_reduce_print (yyvsp, Rule); \
1052 } while (YYID (0))
1053
1054 /* Nonzero means print parse trace.  It is left uninitialized so that
1055    multiple parsers can coexist.  */
1056 int yydebug;
1057 #else /* !YYDEBUG */
1058 # define YYDPRINTF(Args)
1059 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1060 # define YY_STACK_PRINT(Bottom, Top)
1061 # define YY_REDUCE_PRINT(Rule)
1062 #endif /* !YYDEBUG */
1063
1064
1065 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1066 #ifndef YYINITDEPTH
1067 # define YYINITDEPTH 200
1068 #endif
1069
1070 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1071    if the built-in stack extension method is used).
1072
1073    Do not make this value too large; the results are undefined if
1074    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1075    evaluated with infinite-precision integer arithmetic.  */
1076
1077 #ifndef YYMAXDEPTH
1078 # define YYMAXDEPTH 10000
1079 #endif
1080
1081 \f
1082
1083 #if YYERROR_VERBOSE
1084
1085 # ifndef yystrlen
1086 #  if defined __GLIBC__ && defined _STRING_H
1087 #   define yystrlen strlen
1088 #  else
1089 /* Return the length of YYSTR.  */
1090 #if (defined __STDC__ || defined __C99__FUNC__ \
1091      || defined __cplusplus || defined _MSC_VER)
1092 static YYSIZE_T
1093 yystrlen (const char *yystr)
1094 #else
1095 static YYSIZE_T
1096 yystrlen (yystr)
1097     const char *yystr;
1098 #endif
1099 {
1100   YYSIZE_T yylen;
1101   for (yylen = 0; yystr[yylen]; yylen++)
1102     continue;
1103   return yylen;
1104 }
1105 #  endif
1106 # endif
1107
1108 # ifndef yystpcpy
1109 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1110 #   define yystpcpy stpcpy
1111 #  else
1112 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1113    YYDEST.  */
1114 #if (defined __STDC__ || defined __C99__FUNC__ \
1115      || defined __cplusplus || defined _MSC_VER)
1116 static char *
1117 yystpcpy (char *yydest, const char *yysrc)
1118 #else
1119 static char *
1120 yystpcpy (yydest, yysrc)
1121     char *yydest;
1122     const char *yysrc;
1123 #endif
1124 {
1125   char *yyd = yydest;
1126   const char *yys = yysrc;
1127
1128   while ((*yyd++ = *yys++) != '\0')
1129     continue;
1130
1131   return yyd - 1;
1132 }
1133 #  endif
1134 # endif
1135
1136 # ifndef yytnamerr
1137 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1138    quotes and backslashes, so that it's suitable for yyerror.  The
1139    heuristic is that double-quoting is unnecessary unless the string
1140    contains an apostrophe, a comma, or backslash (other than
1141    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1142    null, do not copy; instead, return the length of what the result
1143    would have been.  */
1144 static YYSIZE_T
1145 yytnamerr (char *yyres, const char *yystr)
1146 {
1147   if (*yystr == '"')
1148     {
1149       YYSIZE_T yyn = 0;
1150       char const *yyp = yystr;
1151
1152       for (;;)
1153         switch (*++yyp)
1154           {
1155           case '\'':
1156           case ',':
1157             goto do_not_strip_quotes;
1158
1159           case '\\':
1160             if (*++yyp != '\\')
1161               goto do_not_strip_quotes;
1162             /* Fall through.  */
1163           default:
1164             if (yyres)
1165               yyres[yyn] = *yyp;
1166             yyn++;
1167             break;
1168
1169           case '"':
1170             if (yyres)
1171               yyres[yyn] = '\0';
1172             return yyn;
1173           }
1174     do_not_strip_quotes: ;
1175     }
1176
1177   if (! yyres)
1178     return yystrlen (yystr);
1179
1180   return yystpcpy (yyres, yystr) - yyres;
1181 }
1182 # endif
1183
1184 /* Copy into YYRESULT an error message about the unexpected token
1185    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1186    including the terminating null byte.  If YYRESULT is null, do not
1187    copy anything; just return the number of bytes that would be
1188    copied.  As a special case, return 0 if an ordinary "syntax error"
1189    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1190    size calculation.  */
1191 static YYSIZE_T
1192 yysyntax_error (char *yyresult, int yystate, int yychar)
1193 {
1194   int yyn = yypact[yystate];
1195
1196   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1197     return 0;
1198   else
1199     {
1200       int yytype = YYTRANSLATE (yychar);
1201       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1202       YYSIZE_T yysize = yysize0;
1203       YYSIZE_T yysize1;
1204       int yysize_overflow = 0;
1205       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1206       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1207       int yyx;
1208
1209 # if 0
1210       /* This is so xgettext sees the translatable formats that are
1211          constructed on the fly.  */
1212       YY_("syntax error, unexpected %s");
1213       YY_("syntax error, unexpected %s, expecting %s");
1214       YY_("syntax error, unexpected %s, expecting %s or %s");
1215       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1216       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1217 # endif
1218       char *yyfmt;
1219       char const *yyf;
1220       static char const yyunexpected[] = "syntax error, unexpected %s";
1221       static char const yyexpecting[] = ", expecting %s";
1222       static char const yyor[] = " or %s";
1223       char yyformat[sizeof yyunexpected
1224                     + sizeof yyexpecting - 1
1225                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1226                        * (sizeof yyor - 1))];
1227       char const *yyprefix = yyexpecting;
1228
1229       /* Start YYX at -YYN if negative to avoid negative indexes in
1230          YYCHECK.  */
1231       int yyxbegin = yyn < 0 ? -yyn : 0;
1232
1233       /* Stay within bounds of both yycheck and yytname.  */
1234       int yychecklim = YYLAST - yyn + 1;
1235       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1236       int yycount = 1;
1237
1238       yyarg[0] = yytname[yytype];
1239       yyfmt = yystpcpy (yyformat, yyunexpected);
1240
1241       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1242         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1243           {
1244             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1245               {
1246                 yycount = 1;
1247                 yysize = yysize0;
1248                 yyformat[sizeof yyunexpected - 1] = '\0';
1249                 break;
1250               }
1251             yyarg[yycount++] = yytname[yyx];
1252             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1253             yysize_overflow |= (yysize1 < yysize);
1254             yysize = yysize1;
1255             yyfmt = yystpcpy (yyfmt, yyprefix);
1256             yyprefix = yyor;
1257           }
1258
1259       yyf = YY_(yyformat);
1260       yysize1 = yysize + yystrlen (yyf);
1261       yysize_overflow |= (yysize1 < yysize);
1262       yysize = yysize1;
1263
1264       if (yysize_overflow)
1265         return YYSIZE_MAXIMUM;
1266
1267       if (yyresult)
1268         {
1269           /* Avoid sprintf, as that infringes on the user's name space.
1270              Don't have undefined behavior even if the translation
1271              produced a string with the wrong number of "%s"s.  */
1272           char *yyp = yyresult;
1273           int yyi = 0;
1274           while ((*yyp = *yyf) != '\0')
1275             {
1276               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1277                 {
1278                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1279                   yyf += 2;
1280                 }
1281               else
1282                 {
1283                   yyp++;
1284                   yyf++;
1285                 }
1286             }
1287         }
1288       return yysize;
1289     }
1290 }
1291 #endif /* YYERROR_VERBOSE */
1292 \f
1293
1294 /*-----------------------------------------------.
1295 | Release the memory associated to this symbol.  |
1296 `-----------------------------------------------*/
1297
1298 /*ARGSUSED*/
1299 #if (defined __STDC__ || defined __C99__FUNC__ \
1300      || defined __cplusplus || defined _MSC_VER)
1301 static void
1302 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1303 #else
1304 static void
1305 yydestruct (yymsg, yytype, yyvaluep)
1306     const char *yymsg;
1307     int yytype;
1308     YYSTYPE *yyvaluep;
1309 #endif
1310 {
1311   YYUSE (yyvaluep);
1312
1313   if (!yymsg)
1314     yymsg = "Deleting";
1315   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1316
1317   switch (yytype)
1318     {
1319
1320       default:
1321         break;
1322     }
1323 }
1324 \f
1325
1326 /* Prevent warnings from -Wmissing-prototypes.  */
1327
1328 #ifdef YYPARSE_PARAM
1329 #if defined __STDC__ || defined __cplusplus
1330 int yyparse (void *YYPARSE_PARAM);
1331 #else
1332 int yyparse ();
1333 #endif
1334 #else /* ! YYPARSE_PARAM */
1335 #if defined __STDC__ || defined __cplusplus
1336 int yyparse (void);
1337 #else
1338 int yyparse ();
1339 #endif
1340 #endif /* ! YYPARSE_PARAM */
1341
1342
1343
1344
1345
1346
1347 /*----------.
1348 | yyparse.  |
1349 `----------*/
1350
1351 #ifdef YYPARSE_PARAM
1352 #if (defined __STDC__ || defined __C99__FUNC__ \
1353      || defined __cplusplus || defined _MSC_VER)
1354 int
1355 yyparse (void *YYPARSE_PARAM)
1356 #else
1357 int
1358 yyparse (YYPARSE_PARAM)
1359     void *YYPARSE_PARAM;
1360 #endif
1361 #else /* ! YYPARSE_PARAM */
1362 #if (defined __STDC__ || defined __C99__FUNC__ \
1363      || defined __cplusplus || defined _MSC_VER)
1364 int
1365 yyparse (void)
1366 #else
1367 int
1368 yyparse ()
1369
1370 #endif
1371 #endif
1372 {
1373   /* The look-ahead symbol.  */
1374 int yychar;
1375
1376 /* The semantic value of the look-ahead symbol.  */
1377 YYSTYPE yylval;
1378
1379 /* Number of syntax errors so far.  */
1380 int yynerrs;
1381
1382   int yystate;
1383   int yyn;
1384   int yyresult;
1385   /* Number of tokens to shift before error messages enabled.  */
1386   int yyerrstatus;
1387   /* Look-ahead token as an internal (translated) token number.  */
1388   int yytoken = 0;
1389 #if YYERROR_VERBOSE
1390   /* Buffer for error messages, and its allocated size.  */
1391   char yymsgbuf[128];
1392   char *yymsg = yymsgbuf;
1393   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1394 #endif
1395
1396   /* Three stacks and their tools:
1397      `yyss': related to states,
1398      `yyvs': related to semantic values,
1399      `yyls': related to locations.
1400
1401      Refer to the stacks thru separate pointers, to allow yyoverflow
1402      to reallocate them elsewhere.  */
1403
1404   /* The state stack.  */
1405   yytype_int16 yyssa[YYINITDEPTH];
1406   yytype_int16 *yyss = yyssa;
1407   yytype_int16 *yyssp;
1408
1409   /* The semantic value stack.  */
1410   YYSTYPE yyvsa[YYINITDEPTH];
1411   YYSTYPE *yyvs = yyvsa;
1412   YYSTYPE *yyvsp;
1413
1414
1415
1416 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1417
1418   YYSIZE_T yystacksize = YYINITDEPTH;
1419
1420   /* The variables used to return semantic value and location from the
1421      action routines.  */
1422   YYSTYPE yyval;
1423
1424
1425   /* The number of symbols on the RHS of the reduced rule.
1426      Keep to zero when no symbol should be popped.  */
1427   int yylen = 0;
1428
1429   YYDPRINTF ((stderr, "Starting parse\n"));
1430
1431   yystate = 0;
1432   yyerrstatus = 0;
1433   yynerrs = 0;
1434   yychar = YYEMPTY;             /* Cause a token to be read.  */
1435
1436   /* Initialize stack pointers.
1437      Waste one element of value and location stack
1438      so that they stay on the same level as the state stack.
1439      The wasted elements are never initialized.  */
1440
1441   yyssp = yyss;
1442   yyvsp = yyvs;
1443
1444   goto yysetstate;
1445
1446 /*------------------------------------------------------------.
1447 | yynewstate -- Push a new state, which is found in yystate.  |
1448 `------------------------------------------------------------*/
1449  yynewstate:
1450   /* In all cases, when you get here, the value and location stacks
1451      have just been pushed.  So pushing a state here evens the stacks.  */
1452   yyssp++;
1453
1454  yysetstate:
1455   *yyssp = yystate;
1456
1457   if (yyss + yystacksize - 1 <= yyssp)
1458     {
1459       /* Get the current used size of the three stacks, in elements.  */
1460       YYSIZE_T yysize = yyssp - yyss + 1;
1461
1462 #ifdef yyoverflow
1463       {
1464         /* Give user a chance to reallocate the stack.  Use copies of
1465            these so that the &'s don't force the real ones into
1466            memory.  */
1467         YYSTYPE *yyvs1 = yyvs;
1468         yytype_int16 *yyss1 = yyss;
1469
1470
1471         /* Each stack pointer address is followed by the size of the
1472            data in use in that stack, in bytes.  This used to be a
1473            conditional around just the two extra args, but that might
1474            be undefined if yyoverflow is a macro.  */
1475         yyoverflow (YY_("memory exhausted"),
1476                     &yyss1, yysize * sizeof (*yyssp),
1477                     &yyvs1, yysize * sizeof (*yyvsp),
1478
1479                     &yystacksize);
1480
1481         yyss = yyss1;
1482         yyvs = yyvs1;
1483       }
1484 #else /* no yyoverflow */
1485 # ifndef YYSTACK_RELOCATE
1486       goto yyexhaustedlab;
1487 # else
1488       /* Extend the stack our own way.  */
1489       if (YYMAXDEPTH <= yystacksize)
1490         goto yyexhaustedlab;
1491       yystacksize *= 2;
1492       if (YYMAXDEPTH < yystacksize)
1493         yystacksize = YYMAXDEPTH;
1494
1495       {
1496         yytype_int16 *yyss1 = yyss;
1497         union yyalloc *yyptr =
1498           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1499         if (! yyptr)
1500           goto yyexhaustedlab;
1501         YYSTACK_RELOCATE (yyss);
1502         YYSTACK_RELOCATE (yyvs);
1503
1504 #  undef YYSTACK_RELOCATE
1505         if (yyss1 != yyssa)
1506           YYSTACK_FREE (yyss1);
1507       }
1508 # endif
1509 #endif /* no yyoverflow */
1510
1511       yyssp = yyss + yysize - 1;
1512       yyvsp = yyvs + yysize - 1;
1513
1514
1515       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1516                   (unsigned long int) yystacksize));
1517
1518       if (yyss + yystacksize - 1 <= yyssp)
1519         YYABORT;
1520     }
1521
1522   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1523
1524   goto yybackup;
1525
1526 /*-----------.
1527 | yybackup.  |
1528 `-----------*/
1529 yybackup:
1530
1531   /* Do appropriate processing given the current state.  Read a
1532      look-ahead token if we need one and don't already have one.  */
1533
1534   /* First try to decide what to do without reference to look-ahead token.  */
1535   yyn = yypact[yystate];
1536   if (yyn == YYPACT_NINF)
1537     goto yydefault;
1538
1539   /* Not known => get a look-ahead token if don't already have one.  */
1540
1541   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1542   if (yychar == YYEMPTY)
1543     {
1544       YYDPRINTF ((stderr, "Reading a token: "));
1545       yychar = YYLEX;
1546     }
1547
1548   if (yychar <= YYEOF)
1549     {
1550       yychar = yytoken = YYEOF;
1551       YYDPRINTF ((stderr, "Now at end of input.\n"));
1552     }
1553   else
1554     {
1555       yytoken = YYTRANSLATE (yychar);
1556       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1557     }
1558
1559   /* If the proper action on seeing token YYTOKEN is to reduce or to
1560      detect an error, take that action.  */
1561   yyn += yytoken;
1562   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1563     goto yydefault;
1564   yyn = yytable[yyn];
1565   if (yyn <= 0)
1566     {
1567       if (yyn == 0 || yyn == YYTABLE_NINF)
1568         goto yyerrlab;
1569       yyn = -yyn;
1570       goto yyreduce;
1571     }
1572
1573   if (yyn == YYFINAL)
1574     YYACCEPT;
1575
1576   /* Count tokens shifted since error; after three, turn off error
1577      status.  */
1578   if (yyerrstatus)
1579     yyerrstatus--;
1580
1581   /* Shift the look-ahead token.  */
1582   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1583
1584   /* Discard the shifted token unless it is eof.  */
1585   if (yychar != YYEOF)
1586     yychar = YYEMPTY;
1587
1588   yystate = yyn;
1589   *++yyvsp = yylval;
1590
1591   goto yynewstate;
1592
1593
1594 /*-----------------------------------------------------------.
1595 | yydefault -- do the default action for the current state.  |
1596 `-----------------------------------------------------------*/
1597 yydefault:
1598   yyn = yydefact[yystate];
1599   if (yyn == 0)
1600     goto yyerrlab;
1601   goto yyreduce;
1602
1603
1604 /*-----------------------------.
1605 | yyreduce -- Do a reduction.  |
1606 `-----------------------------*/
1607 yyreduce:
1608   /* yyn is the number of a rule to reduce with.  */
1609   yylen = yyr2[yyn];
1610
1611   /* If YYLEN is nonzero, implement the default value of the action:
1612      `$$ = $1'.
1613
1614      Otherwise, the following line sets YYVAL to garbage.
1615      This behavior is undocumented and Bison
1616      users should not rely upon it.  Assigning to YYVAL
1617      unconditionally makes the parser a bit smaller, and it avoids a
1618      GCC warning that YYVAL may be used uninitialized.  */
1619   yyval = yyvsp[1-yylen];
1620
1621
1622   YY_REDUCE_PRINT (yyn);
1623   switch (yyn)
1624     {
1625         case 6:
1626 #line 167 "cmDependsFortranParser.y"
1627     {
1628     free((yyvsp[(1) - (4)].string));
1629     }
1630     break;
1631
1632   case 7:
1633 #line 173 "cmDependsFortranParser.y"
1634     {
1635     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (2)].string), "interface"))
1636       {
1637       cmDependsFortranParser* parser =
1638         cmDependsFortran_yyget_extra(yyscanner);
1639       cmDependsFortranParser_SetInInterface(parser, true);
1640       }
1641     free((yyvsp[(1) - (2)].string));
1642     }
1643     break;
1644
1645   case 8:
1646 #line 183 "cmDependsFortranParser.y"
1647     {
1648     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "use"))
1649       {
1650       cmDependsFortranParser* parser =
1651         cmDependsFortran_yyget_extra(yyscanner);
1652       cmDependsFortranParser_RuleUse(parser, (yyvsp[(2) - (4)].string));
1653       }
1654     else if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "module"))
1655       {
1656       cmDependsFortranParser* parser =
1657         cmDependsFortran_yyget_extra(yyscanner);
1658       cmDependsFortranParser_RuleModule(parser, (yyvsp[(2) - (4)].string));
1659       }
1660     else if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "interface"))
1661       {
1662       cmDependsFortranParser* parser =
1663         cmDependsFortran_yyget_extra(yyscanner);
1664       cmDependsFortranParser_SetInInterface(parser, true);
1665       }
1666     else if (cmDependsFortranParserIsKeyword((yyvsp[(2) - (4)].string), "interface") &&
1667              cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "end"))
1668       {
1669       cmDependsFortranParser* parser =
1670         cmDependsFortran_yyget_extra(yyscanner);
1671       cmDependsFortranParser_SetInInterface(parser, false);
1672       }
1673     free((yyvsp[(1) - (4)].string));
1674     free((yyvsp[(2) - (4)].string));
1675     }
1676     break;
1677
1678   case 9:
1679 #line 213 "cmDependsFortranParser.y"
1680     {
1681     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (5)].string), "use"))
1682       {
1683       cmDependsFortranParser* parser =
1684         cmDependsFortran_yyget_extra(yyscanner);
1685       cmDependsFortranParser_RuleUse(parser, (yyvsp[(3) - (5)].string));
1686       }
1687     free((yyvsp[(1) - (5)].string));
1688     free((yyvsp[(3) - (5)].string));
1689     }
1690     break;
1691
1692   case 10:
1693 #line 224 "cmDependsFortranParser.y"
1694     {
1695     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (7)].string), "use") &&
1696         cmDependsFortranParserIsKeyword((yyvsp[(3) - (7)].string), "non_intrinsic") )
1697       {
1698       cmDependsFortranParser* parser =
1699         cmDependsFortran_yyget_extra(yyscanner);
1700       cmDependsFortranParser_RuleUse(parser, (yyvsp[(5) - (7)].string));
1701       }
1702     free((yyvsp[(1) - (7)].string));
1703     free((yyvsp[(3) - (7)].string));
1704     free((yyvsp[(5) - (7)].string));
1705     }
1706     break;
1707
1708   case 11:
1709 #line 237 "cmDependsFortranParser.y"
1710     {
1711     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "include"))
1712       {
1713       cmDependsFortranParser* parser =
1714         cmDependsFortran_yyget_extra(yyscanner);
1715       cmDependsFortranParser_RuleInclude(parser, (yyvsp[(2) - (4)].string));
1716       }
1717     free((yyvsp[(1) - (4)].string));
1718     free((yyvsp[(2) - (4)].string));
1719     }
1720     break;
1721
1722   case 12:
1723 #line 248 "cmDependsFortranParser.y"
1724     {
1725     cmDependsFortranParser* parser =
1726       cmDependsFortran_yyget_extra(yyscanner);
1727     cmDependsFortranParser_RuleInclude(parser, (yyvsp[(2) - (4)].string));
1728     free((yyvsp[(2) - (4)].string));
1729     }
1730     break;
1731
1732   case 13:
1733 #line 255 "cmDependsFortranParser.y"
1734     {
1735     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1736     cmDependsFortranParser_RuleDefine(parser, (yyvsp[(2) - (4)].string));
1737     free((yyvsp[(2) - (4)].string));
1738     }
1739     break;
1740
1741   case 14:
1742 #line 261 "cmDependsFortranParser.y"
1743     {
1744     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1745     cmDependsFortranParser_RuleUndef(parser, (yyvsp[(2) - (4)].string));
1746     free((yyvsp[(2) - (4)].string));
1747     }
1748     break;
1749
1750   case 15:
1751 #line 267 "cmDependsFortranParser.y"
1752     {
1753     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1754     cmDependsFortranParser_RuleIfdef(parser, (yyvsp[(2) - (4)].string));
1755     free((yyvsp[(2) - (4)].string));
1756     }
1757     break;
1758
1759   case 16:
1760 #line 273 "cmDependsFortranParser.y"
1761     {
1762     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1763     cmDependsFortranParser_RuleIfndef(parser, (yyvsp[(2) - (4)].string));
1764     free((yyvsp[(2) - (4)].string));
1765     }
1766     break;
1767
1768   case 17:
1769 #line 279 "cmDependsFortranParser.y"
1770     {
1771     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1772     cmDependsFortranParser_RuleIf(parser);
1773     }
1774     break;
1775
1776   case 18:
1777 #line 284 "cmDependsFortranParser.y"
1778     {
1779     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1780     cmDependsFortranParser_RuleElif(parser);
1781     }
1782     break;
1783
1784   case 19:
1785 #line 289 "cmDependsFortranParser.y"
1786     {
1787     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1788     cmDependsFortranParser_RuleElse(parser);
1789     }
1790     break;
1791
1792   case 20:
1793 #line 294 "cmDependsFortranParser.y"
1794     {
1795     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
1796     cmDependsFortranParser_RuleEndif(parser);
1797     }
1798     break;
1799
1800   case 21:
1801 #line 299 "cmDependsFortranParser.y"
1802     {
1803     free((yyvsp[(1) - (4)].string));
1804     }
1805     break;
1806
1807   case 46:
1808 #line 321 "cmDependsFortranParser.y"
1809     { free ((yyvsp[(1) - (1)].string)); }
1810     break;
1811
1812   case 47:
1813 #line 322 "cmDependsFortranParser.y"
1814     { free ((yyvsp[(1) - (1)].string)); }
1815     break;
1816
1817
1818 /* Line 1267 of yacc.c.  */
1819 #line 1820 "cmDependsFortranParser.cxx"
1820       default: break;
1821     }
1822   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1823
1824   YYPOPSTACK (yylen);
1825   yylen = 0;
1826   YY_STACK_PRINT (yyss, yyssp);
1827
1828   *++yyvsp = yyval;
1829
1830
1831   /* Now `shift' the result of the reduction.  Determine what state
1832      that goes to, based on the state we popped back to and the rule
1833      number reduced by.  */
1834
1835   yyn = yyr1[yyn];
1836
1837   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1838   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1839     yystate = yytable[yystate];
1840   else
1841     yystate = yydefgoto[yyn - YYNTOKENS];
1842
1843   goto yynewstate;
1844
1845
1846 /*------------------------------------.
1847 | yyerrlab -- here on detecting error |
1848 `------------------------------------*/
1849 yyerrlab:
1850   /* If not already recovering from an error, report this error.  */
1851   if (!yyerrstatus)
1852     {
1853       ++yynerrs;
1854 #if ! YYERROR_VERBOSE
1855       yyerror (YY_("syntax error"));
1856 #else
1857       {
1858         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1859         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1860           {
1861             YYSIZE_T yyalloc = 2 * yysize;
1862             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1863               yyalloc = YYSTACK_ALLOC_MAXIMUM;
1864             if (yymsg != yymsgbuf)
1865               YYSTACK_FREE (yymsg);
1866             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1867             if (yymsg)
1868               yymsg_alloc = yyalloc;
1869             else
1870               {
1871                 yymsg = yymsgbuf;
1872                 yymsg_alloc = sizeof yymsgbuf;
1873               }
1874           }
1875
1876         if (0 < yysize && yysize <= yymsg_alloc)
1877           {
1878             (void) yysyntax_error (yymsg, yystate, yychar);
1879             yyerror (yymsg);
1880           }
1881         else
1882           {
1883             yyerror (YY_("syntax error"));
1884             if (yysize != 0)
1885               goto yyexhaustedlab;
1886           }
1887       }
1888 #endif
1889     }
1890
1891
1892
1893   if (yyerrstatus == 3)
1894     {
1895       /* If just tried and failed to reuse look-ahead token after an
1896          error, discard it.  */
1897
1898       if (yychar <= YYEOF)
1899         {
1900           /* Return failure if at end of input.  */
1901           if (yychar == YYEOF)
1902             YYABORT;
1903         }
1904       else
1905         {
1906           yydestruct ("Error: discarding",
1907                       yytoken, &yylval);
1908           yychar = YYEMPTY;
1909         }
1910     }
1911
1912 #if 0
1913   /* Else will try to reuse look-ahead token after shifting the error
1914      token.  */
1915   goto yyerrlab1;
1916
1917
1918 /*---------------------------------------------------.
1919 | yyerrorlab -- error raised explicitly by YYERROR.  |
1920 `---------------------------------------------------*/
1921 yyerrorlab:
1922
1923   /* Pacify compilers like GCC when the user code never invokes
1924      YYERROR and the label yyerrorlab therefore never appears in user
1925      code.  */
1926   if (/*CONSTCOND*/ 0)
1927      goto yyerrorlab;
1928
1929   /* Do not reclaim the symbols of the rule which action triggered
1930      this YYERROR.  */
1931   YYPOPSTACK (yylen);
1932   yylen = 0;
1933   YY_STACK_PRINT (yyss, yyssp);
1934   yystate = *yyssp;
1935   goto yyerrlab1;
1936
1937
1938 /*-------------------------------------------------------------.
1939 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1940 `-------------------------------------------------------------*/
1941 yyerrlab1:
1942 #endif
1943   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1944
1945   for (;;)
1946     {
1947       yyn = yypact[yystate];
1948       if (yyn != YYPACT_NINF)
1949         {
1950           yyn += YYTERROR;
1951           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1952             {
1953               yyn = yytable[yyn];
1954               if (0 < yyn)
1955                 break;
1956             }
1957         }
1958
1959       /* Pop the current state because it cannot handle the error token.  */
1960       if (yyssp == yyss)
1961         YYABORT;
1962
1963
1964       yydestruct ("Error: popping",
1965                   yystos[yystate], yyvsp);
1966       YYPOPSTACK (1);
1967       yystate = *yyssp;
1968       YY_STACK_PRINT (yyss, yyssp);
1969     }
1970
1971   if (yyn == YYFINAL)
1972     YYACCEPT;
1973
1974   *++yyvsp = yylval;
1975
1976
1977   /* Shift the error token.  */
1978   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1979
1980   yystate = yyn;
1981   goto yynewstate;
1982
1983
1984 /*-------------------------------------.
1985 | yyacceptlab -- YYACCEPT comes here.  |
1986 `-------------------------------------*/
1987 yyacceptlab:
1988   yyresult = 0;
1989   goto yyreturn;
1990
1991 /*-----------------------------------.
1992 | yyabortlab -- YYABORT comes here.  |
1993 `-----------------------------------*/
1994 yyabortlab:
1995   yyresult = 1;
1996   goto yyreturn;
1997
1998 #ifndef yyoverflow
1999 /*-------------------------------------------------.
2000 | yyexhaustedlab -- memory exhaustion comes here.  |
2001 `-------------------------------------------------*/
2002 yyexhaustedlab:
2003   yyerror (YY_("memory exhausted"));
2004   yyresult = 2;
2005   /* Fall through.  */
2006 #endif
2007
2008 yyreturn:
2009   if (yychar != YYEOF && yychar != YYEMPTY)
2010      yydestruct ("Cleanup: discarding lookahead",
2011                  yytoken, &yylval);
2012   /* Do not reclaim the symbols of the rule which action triggered
2013      this YYABORT or YYACCEPT.  */
2014   YYPOPSTACK (yylen);
2015   YY_STACK_PRINT (yyss, yyssp);
2016   while (yyssp != yyss)
2017     {
2018       yydestruct ("Cleanup: popping",
2019                   yystos[*yyssp], yyvsp);
2020       YYPOPSTACK (1);
2021     }
2022 #ifndef yyoverflow
2023   if (yyss != yyssa)
2024     YYSTACK_FREE (yyss);
2025 #endif
2026 #if YYERROR_VERBOSE
2027   if (yymsg != yymsgbuf)
2028     YYSTACK_FREE (yymsg);
2029 #endif
2030   /* Make sure YYID is used.  */
2031   return YYID (yyresult);
2032 }
2033
2034
2035 #line 330 "cmDependsFortranParser.y"
2036
2037 /* End of grammar */
2038