You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2084 lines
72 KiB
2084 lines
72 KiB
/* A Bison parser, made by GNU Bison 3.8.2. */
|
|
|
|
/* Bison implementation for Yacc-like parsers in C
|
|
|
|
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
|
|
Inc.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
|
|
|
/* As a special exception, you may create a larger work that contains
|
|
part or all of the Bison parser skeleton and distribute that work
|
|
under terms of your choice, so long as that work isn't itself a
|
|
parser generator using the skeleton or a modified version thereof
|
|
as a parser skeleton. Alternatively, if you modify or redistribute
|
|
the parser skeleton itself, you may (at your option) remove this
|
|
special exception, which will cause the skeleton and the resulting
|
|
Bison output files to be licensed under the GNU General Public
|
|
License without this special exception.
|
|
|
|
This special exception was added by the Free Software Foundation in
|
|
version 2.2 of Bison. */
|
|
|
|
/* C LALR(1) parser skeleton written by Richard Stallman, by
|
|
simplifying the original so-called "semantic" parser. */
|
|
|
|
/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
|
|
especially those whose name start with YY_ or yy_. They are
|
|
private implementation details that can be changed or removed. */
|
|
|
|
/* All symbols defined below should begin with yy or YY, to avoid
|
|
infringing on user name space. This should be done even for local
|
|
variables, as they might otherwise be expanded by user macros.
|
|
There are some unavoidable exceptions within include files to
|
|
define necessary library symbols; they are noted "INFRINGES ON
|
|
USER NAME SPACE" below. */
|
|
|
|
/* Identify Bison output, and Bison version. */
|
|
#define YYBISON 30802
|
|
|
|
/* Bison version string. */
|
|
#define YYBISON_VERSION "3.8.2"
|
|
|
|
/* Skeleton name. */
|
|
#define YYSKELETON_NAME "yacc.c"
|
|
|
|
/* Pure parsers. */
|
|
#define YYPURE 1
|
|
|
|
/* Push parsers. */
|
|
#define YYPUSH 0
|
|
|
|
/* Pull parsers. */
|
|
#define YYPULL 1
|
|
|
|
|
|
/* Substitute the variable and function names. */
|
|
#define yyparse cmFortran_yyparse
|
|
#define yylex cmFortran_yylex
|
|
#define yyerror cmFortran_yyerror
|
|
#define yydebug cmFortran_yydebug
|
|
#define yynerrs cmFortran_yynerrs
|
|
|
|
/* First part of user prologue. */
|
|
#line 1 "cmFortranParser.y"
|
|
|
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
/*-------------------------------------------------------------------------
|
|
Portions of this source have been derived from makedepf90 version 2.8.8,
|
|
|
|
Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
|
|
|
|
The code was originally distributed under the GPL but permission
|
|
from the copyright holder has been obtained to distribute this
|
|
derived work under the CMake license.
|
|
-------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
|
|
This file must be translated to C and modified to build everywhere.
|
|
|
|
Run bison like this:
|
|
|
|
bison --name-prefix=cmFortran_yy
|
|
--defines=cmFortranParserTokens.h
|
|
-ocmFortranParser.cxx
|
|
cmFortranParser.y
|
|
|
|
*/
|
|
|
|
#include "cmConfigure.h" // IWYU pragma: keep
|
|
|
|
#include "cmsys/String.h"
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
#define cmFortranParser_cxx
|
|
#include "cmFortranParser.h" /* Interface to parser object. */
|
|
|
|
/* Forward declare the lexer entry point. */
|
|
YY_DECL;
|
|
|
|
/* Helper function to forward error callback from parser. */
|
|
static void cmFortran_yyerror(yyscan_t yyscanner, const char* message)
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_Error(parser, message);
|
|
}
|
|
|
|
/* Disable some warnings in the generated code. */
|
|
#ifdef _MSC_VER
|
|
# pragma warning (disable: 4102) /* Unused goto label. */
|
|
# pragma warning (disable: 4065) /* Switch contains default but no case. */
|
|
# pragma warning (disable: 4701) /* Local variable may not be initialized. */
|
|
# pragma warning (disable: 4702) /* Unreachable code. */
|
|
# pragma warning (disable: 4127) /* Conditional expression is constant. */
|
|
# pragma warning (disable: 4244) /* Conversion to smaller type, data loss. */
|
|
#endif
|
|
#if defined(__GNUC__) && __GNUC__ >= 8
|
|
# pragma GCC diagnostic ignored "-Wconversion"
|
|
# pragma GCC diagnostic ignored "-Wfree-nonheap-object"
|
|
#endif
|
|
#if defined(__clang__) && defined(__has_warning)
|
|
# if __has_warning("-Wunused-but-set-variable")
|
|
# pragma clang diagnostic ignored "-Wunused-but-set-variable"
|
|
# endif
|
|
#endif
|
|
|
|
#line 142 "cmFortranParser.cxx"
|
|
|
|
# ifndef YY_CAST
|
|
# ifdef __cplusplus
|
|
# define YY_CAST(Type, Val) static_cast<Type> (Val)
|
|
# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
|
|
# else
|
|
# define YY_CAST(Type, Val) ((Type) (Val))
|
|
# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
|
|
# endif
|
|
# endif
|
|
# ifndef YY_NULLPTR
|
|
# if defined __cplusplus
|
|
# if 201103L <= __cplusplus
|
|
# define YY_NULLPTR nullptr
|
|
# else
|
|
# define YY_NULLPTR 0
|
|
# endif
|
|
# else
|
|
# define YY_NULLPTR ((void*)0)
|
|
# endif
|
|
# endif
|
|
|
|
#include "cmFortranParserTokens.h"
|
|
/* Symbol kind. */
|
|
enum yysymbol_kind_t
|
|
{
|
|
YYSYMBOL_YYEMPTY = -2,
|
|
YYSYMBOL_YYEOF = 0, /* "end of file" */
|
|
YYSYMBOL_YYerror = 1, /* error */
|
|
YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
|
|
YYSYMBOL_EOSTMT = 3, /* EOSTMT */
|
|
YYSYMBOL_ASSIGNMENT_OP = 4, /* ASSIGNMENT_OP */
|
|
YYSYMBOL_GARBAGE = 5, /* GARBAGE */
|
|
YYSYMBOL_CPP_LINE_DIRECTIVE = 6, /* CPP_LINE_DIRECTIVE */
|
|
YYSYMBOL_CPP_INCLUDE = 7, /* CPP_INCLUDE */
|
|
YYSYMBOL_F90PPR_INCLUDE = 8, /* F90PPR_INCLUDE */
|
|
YYSYMBOL_COCO_INCLUDE = 9, /* COCO_INCLUDE */
|
|
YYSYMBOL_F90PPR_DEFINE = 10, /* F90PPR_DEFINE */
|
|
YYSYMBOL_CPP_DEFINE = 11, /* CPP_DEFINE */
|
|
YYSYMBOL_F90PPR_UNDEF = 12, /* F90PPR_UNDEF */
|
|
YYSYMBOL_CPP_UNDEF = 13, /* CPP_UNDEF */
|
|
YYSYMBOL_CPP_IFDEF = 14, /* CPP_IFDEF */
|
|
YYSYMBOL_CPP_IFNDEF = 15, /* CPP_IFNDEF */
|
|
YYSYMBOL_CPP_IF = 16, /* CPP_IF */
|
|
YYSYMBOL_CPP_ELSE = 17, /* CPP_ELSE */
|
|
YYSYMBOL_CPP_ELIF = 18, /* CPP_ELIF */
|
|
YYSYMBOL_CPP_ENDIF = 19, /* CPP_ENDIF */
|
|
YYSYMBOL_F90PPR_IFDEF = 20, /* F90PPR_IFDEF */
|
|
YYSYMBOL_F90PPR_IFNDEF = 21, /* F90PPR_IFNDEF */
|
|
YYSYMBOL_F90PPR_IF = 22, /* F90PPR_IF */
|
|
YYSYMBOL_F90PPR_ELSE = 23, /* F90PPR_ELSE */
|
|
YYSYMBOL_F90PPR_ELIF = 24, /* F90PPR_ELIF */
|
|
YYSYMBOL_F90PPR_ENDIF = 25, /* F90PPR_ENDIF */
|
|
YYSYMBOL_COMMA = 26, /* COMMA */
|
|
YYSYMBOL_COLON = 27, /* COLON */
|
|
YYSYMBOL_DCOLON = 28, /* DCOLON */
|
|
YYSYMBOL_LPAREN = 29, /* LPAREN */
|
|
YYSYMBOL_RPAREN = 30, /* RPAREN */
|
|
YYSYMBOL_UNTERMINATED_STRING = 31, /* UNTERMINATED_STRING */
|
|
YYSYMBOL_STRING = 32, /* STRING */
|
|
YYSYMBOL_WORD = 33, /* WORD */
|
|
YYSYMBOL_CPP_INCLUDE_ANGLE = 34, /* CPP_INCLUDE_ANGLE */
|
|
YYSYMBOL_END = 35, /* END */
|
|
YYSYMBOL_INCLUDE = 36, /* INCLUDE */
|
|
YYSYMBOL_INTERFACE = 37, /* INTERFACE */
|
|
YYSYMBOL_MODULE = 38, /* MODULE */
|
|
YYSYMBOL_SUBMODULE = 39, /* SUBMODULE */
|
|
YYSYMBOL_USE = 40, /* USE */
|
|
YYSYMBOL_YYACCEPT = 41, /* $accept */
|
|
YYSYMBOL_code = 42, /* code */
|
|
YYSYMBOL_stmt = 43, /* stmt */
|
|
YYSYMBOL_include = 44, /* include */
|
|
YYSYMBOL_define = 45, /* define */
|
|
YYSYMBOL_undef = 46, /* undef */
|
|
YYSYMBOL_ifdef = 47, /* ifdef */
|
|
YYSYMBOL_ifndef = 48, /* ifndef */
|
|
YYSYMBOL_if = 49, /* if */
|
|
YYSYMBOL_elif = 50, /* elif */
|
|
YYSYMBOL_else = 51, /* else */
|
|
YYSYMBOL_endif = 52, /* endif */
|
|
YYSYMBOL_other = 53, /* other */
|
|
YYSYMBOL_misc_code = 54 /* misc_code */
|
|
};
|
|
typedef enum yysymbol_kind_t yysymbol_kind_t;
|
|
|
|
|
|
|
|
|
|
#ifdef short
|
|
# undef short
|
|
#endif
|
|
|
|
/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
|
|
<limits.h> and (if available) <stdint.h> are included
|
|
so that the code can choose integer types of a good width. */
|
|
|
|
#ifndef __PTRDIFF_MAX__
|
|
# include <limits.h> /* INFRINGES ON USER NAME SPACE */
|
|
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
|
|
# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define YY_STDINT_H
|
|
# endif
|
|
#endif
|
|
|
|
/* Narrow types that promote to a signed type and that can represent a
|
|
signed or unsigned integer of at least N bits. In tables they can
|
|
save space and decrease cache pressure. Promoting to a signed type
|
|
helps avoid bugs in integer arithmetic. */
|
|
|
|
#ifdef __INT_LEAST8_MAX__
|
|
typedef __INT_LEAST8_TYPE__ yytype_int8;
|
|
#elif defined YY_STDINT_H
|
|
typedef int_least8_t yytype_int8;
|
|
#else
|
|
typedef signed char yytype_int8;
|
|
#endif
|
|
|
|
#ifdef __INT_LEAST16_MAX__
|
|
typedef __INT_LEAST16_TYPE__ yytype_int16;
|
|
#elif defined YY_STDINT_H
|
|
typedef int_least16_t yytype_int16;
|
|
#else
|
|
typedef short yytype_int16;
|
|
#endif
|
|
|
|
/* Work around bug in HP-UX 11.23, which defines these macros
|
|
incorrectly for preprocessor constants. This workaround can likely
|
|
be removed in 2023, as HPE has promised support for HP-UX 11.23
|
|
(aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
|
|
<https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
|
|
#ifdef __hpux
|
|
# undef UINT_LEAST8_MAX
|
|
# undef UINT_LEAST16_MAX
|
|
# define UINT_LEAST8_MAX 255
|
|
# define UINT_LEAST16_MAX 65535
|
|
#endif
|
|
|
|
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
|
|
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
|
|
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
|
|
&& UINT_LEAST8_MAX <= INT_MAX)
|
|
typedef uint_least8_t yytype_uint8;
|
|
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
|
|
typedef unsigned char yytype_uint8;
|
|
#else
|
|
typedef short yytype_uint8;
|
|
#endif
|
|
|
|
#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
|
|
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
|
|
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
|
|
&& UINT_LEAST16_MAX <= INT_MAX)
|
|
typedef uint_least16_t yytype_uint16;
|
|
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
|
|
typedef unsigned short yytype_uint16;
|
|
#else
|
|
typedef int yytype_uint16;
|
|
#endif
|
|
|
|
#ifndef YYPTRDIFF_T
|
|
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
|
|
# define YYPTRDIFF_T __PTRDIFF_TYPE__
|
|
# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
|
|
# elif defined PTRDIFF_MAX
|
|
# ifndef ptrdiff_t
|
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
|
|
# endif
|
|
# define YYPTRDIFF_T ptrdiff_t
|
|
# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
|
|
# else
|
|
# define YYPTRDIFF_T long
|
|
# define YYPTRDIFF_MAXIMUM LONG_MAX
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef YYSIZE_T
|
|
# ifdef __SIZE_TYPE__
|
|
# define YYSIZE_T __SIZE_TYPE__
|
|
# elif defined size_t
|
|
# define YYSIZE_T size_t
|
|
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
|
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define YYSIZE_T size_t
|
|
# else
|
|
# define YYSIZE_T unsigned
|
|
# endif
|
|
#endif
|
|
|
|
#define YYSIZE_MAXIMUM \
|
|
YY_CAST (YYPTRDIFF_T, \
|
|
(YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
|
|
? YYPTRDIFF_MAXIMUM \
|
|
: YY_CAST (YYSIZE_T, -1)))
|
|
|
|
#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
|
|
|
|
|
|
/* Stored state numbers (used for stacks). */
|
|
typedef yytype_int8 yy_state_t;
|
|
|
|
/* State numbers in computations. */
|
|
typedef int yy_state_fast_t;
|
|
|
|
#ifndef YY_
|
|
# if defined YYENABLE_NLS && YYENABLE_NLS
|
|
# if ENABLE_NLS
|
|
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
|
|
# endif
|
|
# endif
|
|
# ifndef YY_
|
|
# define YY_(Msgid) Msgid
|
|
# endif
|
|
#endif
|
|
|
|
|
|
#ifndef YY_ATTRIBUTE_PURE
|
|
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
|
|
# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
|
|
# else
|
|
# define YY_ATTRIBUTE_PURE
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef YY_ATTRIBUTE_UNUSED
|
|
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
|
|
# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
|
|
# else
|
|
# define YY_ATTRIBUTE_UNUSED
|
|
# endif
|
|
#endif
|
|
|
|
/* Suppress unused-variable warnings by "using" E. */
|
|
#if ! defined lint || defined __GNUC__
|
|
# define YY_USE(E) ((void) (E))
|
|
#else
|
|
# define YY_USE(E) /* empty */
|
|
#endif
|
|
|
|
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
|
|
#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
|
|
# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
|
|
_Pragma ("GCC diagnostic push") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
|
|
# else
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
|
|
_Pragma ("GCC diagnostic push") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
|
|
# endif
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
|
|
_Pragma ("GCC diagnostic pop")
|
|
#else
|
|
# define YY_INITIAL_VALUE(Value) Value
|
|
#endif
|
|
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
#endif
|
|
#ifndef YY_INITIAL_VALUE
|
|
# define YY_INITIAL_VALUE(Value) /* Nothing. */
|
|
#endif
|
|
|
|
#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
|
|
# define YY_IGNORE_USELESS_CAST_BEGIN \
|
|
_Pragma ("GCC diagnostic push") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
|
|
# define YY_IGNORE_USELESS_CAST_END \
|
|
_Pragma ("GCC diagnostic pop")
|
|
#endif
|
|
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
|
|
# define YY_IGNORE_USELESS_CAST_BEGIN
|
|
# define YY_IGNORE_USELESS_CAST_END
|
|
#endif
|
|
|
|
|
|
#define YY_ASSERT(E) ((void) (0 && (E)))
|
|
|
|
#if 1
|
|
|
|
/* The parser invokes alloca or malloc; define the necessary symbols. */
|
|
|
|
# ifdef YYSTACK_USE_ALLOCA
|
|
# if YYSTACK_USE_ALLOCA
|
|
# ifdef __GNUC__
|
|
# define YYSTACK_ALLOC __builtin_alloca
|
|
# elif defined __BUILTIN_VA_ARG_INCR
|
|
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
|
|
# elif defined _AIX
|
|
# define YYSTACK_ALLOC __alloca
|
|
# elif defined _MSC_VER
|
|
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define alloca _alloca
|
|
# else
|
|
# define YYSTACK_ALLOC alloca
|
|
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
|
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
|
|
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
|
|
# ifndef EXIT_SUCCESS
|
|
# define EXIT_SUCCESS 0
|
|
# endif
|
|
# endif
|
|
# endif
|
|
# endif
|
|
# endif
|
|
|
|
# ifdef YYSTACK_ALLOC
|
|
/* Pacify GCC's 'empty if-body' warning. */
|
|
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
|
|
# ifndef YYSTACK_ALLOC_MAXIMUM
|
|
/* The OS might guarantee only one guard page at the bottom of the stack,
|
|
and a page size can be as small as 4096 bytes. So we cannot safely
|
|
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
|
|
to allow for a few compiler-allocated temporary stack slots. */
|
|
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
|
|
# endif
|
|
# else
|
|
# define YYSTACK_ALLOC YYMALLOC
|
|
# define YYSTACK_FREE YYFREE
|
|
# ifndef YYSTACK_ALLOC_MAXIMUM
|
|
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
|
|
# endif
|
|
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
|
|
&& ! ((defined YYMALLOC || defined malloc) \
|
|
&& (defined YYFREE || defined free)))
|
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
|
|
# ifndef EXIT_SUCCESS
|
|
# define EXIT_SUCCESS 0
|
|
# endif
|
|
# endif
|
|
# ifndef YYMALLOC
|
|
# define YYMALLOC malloc
|
|
# if ! defined malloc && ! defined EXIT_SUCCESS
|
|
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
|
|
# endif
|
|
# endif
|
|
# ifndef YYFREE
|
|
# define YYFREE free
|
|
# if ! defined free && ! defined EXIT_SUCCESS
|
|
void free (void *); /* INFRINGES ON USER NAME SPACE */
|
|
# endif
|
|
# endif
|
|
# endif
|
|
#endif /* 1 */
|
|
|
|
#if (! defined yyoverflow \
|
|
&& (! defined __cplusplus \
|
|
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
|
|
|
|
/* A type that is properly aligned for any stack member. */
|
|
union yyalloc
|
|
{
|
|
yy_state_t yyss_alloc;
|
|
YYSTYPE yyvs_alloc;
|
|
};
|
|
|
|
/* The size of the maximum gap between one aligned stack and the next. */
|
|
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
|
|
|
|
/* The size of an array large to enough to hold all stacks, each with
|
|
N elements. */
|
|
# define YYSTACK_BYTES(N) \
|
|
((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
|
|
+ YYSTACK_GAP_MAXIMUM)
|
|
|
|
# define YYCOPY_NEEDED 1
|
|
|
|
/* Relocate STACK from its old location to the new one. The
|
|
local variables YYSIZE and YYSTACKSIZE give the old and new number of
|
|
elements in the stack, and YYPTR gives the new location of the
|
|
stack. Advance YYPTR to a properly aligned location for the next
|
|
stack. */
|
|
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
|
|
do \
|
|
{ \
|
|
YYPTRDIFF_T yynewbytes; \
|
|
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
|
|
Stack = &yyptr->Stack_alloc; \
|
|
yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
|
|
yyptr += yynewbytes / YYSIZEOF (*yyptr); \
|
|
} \
|
|
while (0)
|
|
|
|
#endif
|
|
|
|
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
|
|
/* Copy COUNT objects from SRC to DST. The source and destination do
|
|
not overlap. */
|
|
# ifndef YYCOPY
|
|
# if defined __GNUC__ && 1 < __GNUC__
|
|
# define YYCOPY(Dst, Src, Count) \
|
|
__builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
|
|
# else
|
|
# define YYCOPY(Dst, Src, Count) \
|
|
do \
|
|
{ \
|
|
YYPTRDIFF_T yyi; \
|
|
for (yyi = 0; yyi < (Count); yyi++) \
|
|
(Dst)[yyi] = (Src)[yyi]; \
|
|
} \
|
|
while (0)
|
|
# endif
|
|
# endif
|
|
#endif /* !YYCOPY_NEEDED */
|
|
|
|
/* YYFINAL -- State number of the termination state. */
|
|
#define YYFINAL 2
|
|
/* YYLAST -- Last index in YYTABLE. */
|
|
#define YYLAST 433
|
|
|
|
/* YYNTOKENS -- Number of terminals. */
|
|
#define YYNTOKENS 41
|
|
/* YYNNTS -- Number of nonterminals. */
|
|
#define YYNNTS 14
|
|
/* YYNRULES -- Number of rules. */
|
|
#define YYNRULES 65
|
|
/* YYNSTATES -- Number of states. */
|
|
#define YYNSTATES 123
|
|
|
|
/* YYMAXUTOK -- Last valid token kind. */
|
|
#define YYMAXUTOK 295
|
|
|
|
|
|
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
|
|
as returned by yylex, with out-of-bounds checking. */
|
|
#define YYTRANSLATE(YYX) \
|
|
(0 <= (YYX) && (YYX) <= YYMAXUTOK \
|
|
? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
|
|
: YYSYMBOL_YYUNDEF)
|
|
|
|
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
|
|
as returned by yylex. */
|
|
static const yytype_int8 yytranslate[] =
|
|
{
|
|
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
|
|
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
|
|
25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 39, 40
|
|
};
|
|
|
|
#if YYDEBUG
|
|
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
|
|
static const yytype_int16 yyrline[] =
|
|
{
|
|
0, 106, 106, 106, 109, 113, 118, 123, 129, 136,
|
|
141, 146, 150, 155, 167, 172, 177, 182, 187, 192,
|
|
197, 202, 207, 211, 215, 219, 223, 224, 229, 229,
|
|
229, 230, 230, 231, 231, 232, 232, 233, 233, 234,
|
|
234, 235, 235, 236, 236, 237, 237, 238, 238, 241,
|
|
242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
|
|
252, 253, 254, 255, 256, 257
|
|
};
|
|
#endif
|
|
|
|
/** Accessing symbol of state STATE. */
|
|
#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
|
|
|
|
#if 1
|
|
/* The user-facing name of the symbol whose (internal) number is
|
|
YYSYMBOL. No bounds checking. */
|
|
static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
|
|
|
|
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
|
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
|
|
static const char *const yytname[] =
|
|
{
|
|
"\"end of file\"", "error", "\"invalid token\"", "EOSTMT",
|
|
"ASSIGNMENT_OP", "GARBAGE", "CPP_LINE_DIRECTIVE", "CPP_INCLUDE",
|
|
"F90PPR_INCLUDE", "COCO_INCLUDE", "F90PPR_DEFINE", "CPP_DEFINE",
|
|
"F90PPR_UNDEF", "CPP_UNDEF", "CPP_IFDEF", "CPP_IFNDEF", "CPP_IF",
|
|
"CPP_ELSE", "CPP_ELIF", "CPP_ENDIF", "F90PPR_IFDEF", "F90PPR_IFNDEF",
|
|
"F90PPR_IF", "F90PPR_ELSE", "F90PPR_ELIF", "F90PPR_ENDIF", "COMMA",
|
|
"COLON", "DCOLON", "LPAREN", "RPAREN", "UNTERMINATED_STRING", "STRING",
|
|
"WORD", "CPP_INCLUDE_ANGLE", "END", "INCLUDE", "INTERFACE", "MODULE",
|
|
"SUBMODULE", "USE", "$accept", "code", "stmt", "include", "define",
|
|
"undef", "ifdef", "ifndef", "if", "elif", "else", "endif", "other",
|
|
"misc_code", YY_NULLPTR
|
|
};
|
|
|
|
static const char *
|
|
yysymbol_name (yysymbol_kind_t yysymbol)
|
|
{
|
|
return yytname[yysymbol];
|
|
}
|
|
#endif
|
|
|
|
#define YYPACT_NINF (-39)
|
|
|
|
#define yypact_value_is_default(Yyn) \
|
|
((Yyn) == YYPACT_NINF)
|
|
|
|
#define YYTABLE_NINF (-1)
|
|
|
|
#define yytable_value_is_error(Yyn) \
|
|
0
|
|
|
|
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
|
|
STATE-NUM. */
|
|
static const yytype_int16 yypact[] =
|
|
{
|
|
-39, 21, -39, 5, -39, -23, -39, -39, -39, -39,
|
|
-39, -39, -39, -39, -39, -39, -39, -39, -39, -39,
|
|
-39, -39, -39, -39, -39, -39, -25, -19, 20, -8,
|
|
-15, -22, -39, -6, 14, 15, 16, 17, -39, -39,
|
|
-39, -39, -39, -39, 59, 51, 48, -39, 63, 64,
|
|
35, 36, 37, -39, -39, -39, -39, -39, -39, 75,
|
|
113, 128, 166, 181, -39, -39, -39, -39, -39, -39,
|
|
-39, -39, -39, -39, -39, -39, -39, -39, -39, -39,
|
|
-39, -39, -39, -39, 68, -39, -39, -39, -20, 44,
|
|
-39, 219, 234, 272, 287, 325, 340, -39, -39, -39,
|
|
-39, -39, -39, 40, 41, 42, 378, -39, -39, -39,
|
|
-39, -39, -39, 46, 79, -39, -39, 50, -39, 393,
|
|
90, -39, -39
|
|
};
|
|
|
|
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
|
|
Performed when YYTABLE does not specify something else to do. Zero
|
|
means the default is an error. */
|
|
static const yytype_int8 yydefact[] =
|
|
{
|
|
2, 0, 1, 0, 26, 0, 28, 29, 30, 32,
|
|
31, 34, 33, 35, 37, 39, 43, 41, 45, 36,
|
|
38, 40, 44, 42, 46, 47, 0, 0, 0, 0,
|
|
0, 0, 3, 0, 0, 0, 0, 0, 47, 47,
|
|
47, 47, 27, 47, 0, 0, 0, 4, 0, 0,
|
|
0, 0, 0, 47, 47, 47, 47, 47, 47, 0,
|
|
0, 0, 0, 0, 16, 58, 57, 65, 63, 59,
|
|
60, 61, 62, 64, 56, 49, 50, 51, 52, 53,
|
|
54, 55, 48, 11, 0, 14, 9, 6, 0, 0,
|
|
47, 0, 0, 0, 0, 0, 0, 22, 23, 24,
|
|
25, 15, 10, 0, 0, 0, 0, 5, 17, 18,
|
|
19, 20, 21, 0, 0, 47, 12, 0, 7, 0,
|
|
0, 13, 8
|
|
};
|
|
|
|
/* YYPGOTO[NTERM-NUM]. */
|
|
static const yytype_int8 yypgoto[] =
|
|
{
|
|
-39, -39, -39, -39, -39, -39, -39, -39, -39, -39,
|
|
-39, -39, -38, -39
|
|
};
|
|
|
|
/* YYDEFGOTO[NTERM-NUM]. */
|
|
static const yytype_int8 yydefgoto[] =
|
|
{
|
|
0, 1, 32, 33, 34, 35, 36, 37, 38, 39,
|
|
40, 41, 44, 82
|
|
};
|
|
|
|
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
|
|
positive, shift that token. If negative, reduce the rule whose
|
|
number is the opposite. If YYTABLE_NINF, syntax error. */
|
|
static const yytype_int8 yytable[] =
|
|
{
|
|
59, 60, 61, 62, 51, 63, 52, 103, 42, 43,
|
|
104, 53, 45, 46, 50, 91, 92, 93, 94, 95,
|
|
96, 2, 3, 47, 4, 49, 54, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
|
|
18, 19, 20, 21, 22, 23, 24, 55, 56, 57,
|
|
58, 85, 106, 48, 83, 25, 26, 27, 28, 29,
|
|
30, 31, 64, 65, 66, 67, 86, 87, 88, 89,
|
|
90, 102, 105, 113, 114, 115, 117, 119, 97, 65,
|
|
66, 67, 118, 120, 84, 68, 69, 70, 71, 72,
|
|
73, 74, 75, 122, 76, 77, 78, 79, 80, 81,
|
|
0, 68, 69, 70, 71, 72, 73, 74, 75, 0,
|
|
76, 77, 78, 79, 80, 81, 98, 65, 66, 67,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 99, 65, 66, 67, 0, 0, 0, 0, 68,
|
|
69, 70, 71, 72, 73, 74, 75, 0, 76, 77,
|
|
78, 79, 80, 81, 68, 69, 70, 71, 72, 73,
|
|
74, 75, 0, 76, 77, 78, 79, 80, 81, 100,
|
|
65, 66, 67, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 101, 65, 66, 67, 0, 0,
|
|
0, 0, 68, 69, 70, 71, 72, 73, 74, 75,
|
|
0, 76, 77, 78, 79, 80, 81, 68, 69, 70,
|
|
71, 72, 73, 74, 75, 0, 76, 77, 78, 79,
|
|
80, 81, 107, 65, 66, 67, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 108, 65, 66,
|
|
67, 0, 0, 0, 0, 68, 69, 70, 71, 72,
|
|
73, 74, 75, 0, 76, 77, 78, 79, 80, 81,
|
|
68, 69, 70, 71, 72, 73, 74, 75, 0, 76,
|
|
77, 78, 79, 80, 81, 109, 65, 66, 67, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
110, 65, 66, 67, 0, 0, 0, 0, 68, 69,
|
|
70, 71, 72, 73, 74, 75, 0, 76, 77, 78,
|
|
79, 80, 81, 68, 69, 70, 71, 72, 73, 74,
|
|
75, 0, 76, 77, 78, 79, 80, 81, 111, 65,
|
|
66, 67, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 112, 65, 66, 67, 0, 0, 0,
|
|
0, 68, 69, 70, 71, 72, 73, 74, 75, 0,
|
|
76, 77, 78, 79, 80, 81, 68, 69, 70, 71,
|
|
72, 73, 74, 75, 0, 76, 77, 78, 79, 80,
|
|
81, 116, 65, 66, 67, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 121, 65, 66, 67,
|
|
0, 0, 0, 0, 68, 69, 70, 71, 72, 73,
|
|
74, 75, 0, 76, 77, 78, 79, 80, 81, 68,
|
|
69, 70, 71, 72, 73, 74, 75, 0, 76, 77,
|
|
78, 79, 80, 81
|
|
};
|
|
|
|
static const yytype_int8 yycheck[] =
|
|
{
|
|
38, 39, 40, 41, 26, 43, 28, 27, 3, 32,
|
|
30, 33, 37, 32, 29, 53, 54, 55, 56, 57,
|
|
58, 0, 1, 3, 3, 33, 32, 6, 7, 8,
|
|
9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
|
|
19, 20, 21, 22, 23, 24, 25, 33, 33, 33,
|
|
33, 3, 90, 33, 3, 34, 35, 36, 37, 38,
|
|
39, 40, 3, 4, 5, 6, 3, 3, 33, 33,
|
|
33, 3, 28, 33, 33, 33, 30, 115, 3, 4,
|
|
5, 6, 3, 33, 33, 26, 27, 28, 29, 30,
|
|
31, 32, 33, 3, 35, 36, 37, 38, 39, 40,
|
|
-1, 26, 27, 28, 29, 30, 31, 32, 33, -1,
|
|
35, 36, 37, 38, 39, 40, 3, 4, 5, 6,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 3, 4, 5, 6, -1, -1, -1, -1, 26,
|
|
27, 28, 29, 30, 31, 32, 33, -1, 35, 36,
|
|
37, 38, 39, 40, 26, 27, 28, 29, 30, 31,
|
|
32, 33, -1, 35, 36, 37, 38, 39, 40, 3,
|
|
4, 5, 6, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 3, 4, 5, 6, -1, -1,
|
|
-1, -1, 26, 27, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, 36, 37, 38, 39, 40, 26, 27, 28,
|
|
29, 30, 31, 32, 33, -1, 35, 36, 37, 38,
|
|
39, 40, 3, 4, 5, 6, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
|
|
6, -1, -1, -1, -1, 26, 27, 28, 29, 30,
|
|
31, 32, 33, -1, 35, 36, 37, 38, 39, 40,
|
|
26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
36, 37, 38, 39, 40, 3, 4, 5, 6, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
3, 4, 5, 6, -1, -1, -1, -1, 26, 27,
|
|
28, 29, 30, 31, 32, 33, -1, 35, 36, 37,
|
|
38, 39, 40, 26, 27, 28, 29, 30, 31, 32,
|
|
33, -1, 35, 36, 37, 38, 39, 40, 3, 4,
|
|
5, 6, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 3, 4, 5, 6, -1, -1, -1,
|
|
-1, 26, 27, 28, 29, 30, 31, 32, 33, -1,
|
|
35, 36, 37, 38, 39, 40, 26, 27, 28, 29,
|
|
30, 31, 32, 33, -1, 35, 36, 37, 38, 39,
|
|
40, 3, 4, 5, 6, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
|
|
-1, -1, -1, -1, 26, 27, 28, 29, 30, 31,
|
|
32, 33, -1, 35, 36, 37, 38, 39, 40, 26,
|
|
27, 28, 29, 30, 31, 32, 33, -1, 35, 36,
|
|
37, 38, 39, 40
|
|
};
|
|
|
|
/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
|
|
state STATE-NUM. */
|
|
static const yytype_int8 yystos[] =
|
|
{
|
|
0, 42, 0, 1, 3, 6, 7, 8, 9, 10,
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
|
21, 22, 23, 24, 25, 34, 35, 36, 37, 38,
|
|
39, 40, 43, 44, 45, 46, 47, 48, 49, 50,
|
|
51, 52, 3, 32, 53, 37, 32, 3, 33, 33,
|
|
29, 26, 28, 33, 32, 33, 33, 33, 33, 53,
|
|
53, 53, 53, 53, 3, 4, 5, 6, 26, 27,
|
|
28, 29, 30, 31, 32, 33, 35, 36, 37, 38,
|
|
39, 40, 54, 3, 33, 3, 3, 3, 33, 33,
|
|
33, 53, 53, 53, 53, 53, 53, 3, 3, 3,
|
|
3, 3, 3, 27, 30, 28, 53, 3, 3, 3,
|
|
3, 3, 3, 33, 33, 33, 3, 30, 3, 53,
|
|
33, 3, 3
|
|
};
|
|
|
|
/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
|
|
static const yytype_int8 yyr1[] =
|
|
{
|
|
0, 41, 42, 42, 43, 43, 43, 43, 43, 43,
|
|
43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
|
|
43, 43, 43, 43, 43, 43, 43, 43, 44, 44,
|
|
44, 45, 45, 46, 46, 47, 47, 48, 48, 49,
|
|
49, 50, 50, 51, 51, 52, 52, 53, 53, 54,
|
|
54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
|
|
54, 54, 54, 54, 54, 54
|
|
};
|
|
|
|
/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
|
|
static const yytype_int8 yyr2[] =
|
|
{
|
|
0, 2, 0, 2, 2, 4, 3, 6, 8, 3,
|
|
4, 3, 5, 7, 3, 4, 3, 4, 4, 4,
|
|
4, 4, 3, 3, 3, 3, 1, 2, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 0, 2, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1
|
|
};
|
|
|
|
|
|
enum { YYENOMEM = -2 };
|
|
|
|
#define yyerrok (yyerrstatus = 0)
|
|
#define yyclearin (yychar = YYEMPTY)
|
|
|
|
#define YYACCEPT goto yyacceptlab
|
|
#define YYABORT goto yyabortlab
|
|
#define YYERROR goto yyerrorlab
|
|
#define YYNOMEM goto yyexhaustedlab
|
|
|
|
|
|
#define YYRECOVERING() (!!yyerrstatus)
|
|
|
|
#define YYBACKUP(Token, Value) \
|
|
do \
|
|
if (yychar == YYEMPTY) \
|
|
{ \
|
|
yychar = (Token); \
|
|
yylval = (Value); \
|
|
YYPOPSTACK (yylen); \
|
|
yystate = *yyssp; \
|
|
goto yybackup; \
|
|
} \
|
|
else \
|
|
{ \
|
|
yyerror (yyscanner, YY_("syntax error: cannot back up")); \
|
|
YYERROR; \
|
|
} \
|
|
while (0)
|
|
|
|
/* Backward compatibility with an undocumented macro.
|
|
Use YYerror or YYUNDEF. */
|
|
#define YYERRCODE YYUNDEF
|
|
|
|
|
|
/* Enable debugging if requested. */
|
|
#if YYDEBUG
|
|
|
|
# ifndef YYFPRINTF
|
|
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define YYFPRINTF fprintf
|
|
# endif
|
|
|
|
# define YYDPRINTF(Args) \
|
|
do { \
|
|
if (yydebug) \
|
|
YYFPRINTF Args; \
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
|
|
do { \
|
|
if (yydebug) \
|
|
{ \
|
|
YYFPRINTF (stderr, "%s ", Title); \
|
|
yy_symbol_print (stderr, \
|
|
Kind, Value, yyscanner); \
|
|
YYFPRINTF (stderr, "\n"); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/*-----------------------------------.
|
|
| Print this symbol's value on YYO. |
|
|
`-----------------------------------*/
|
|
|
|
static void
|
|
yy_symbol_value_print (FILE *yyo,
|
|
yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
|
|
{
|
|
FILE *yyoutput = yyo;
|
|
YY_USE (yyoutput);
|
|
YY_USE (yyscanner);
|
|
if (!yyvaluep)
|
|
return;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
YY_USE (yykind);
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
}
|
|
|
|
|
|
/*---------------------------.
|
|
| Print this symbol on YYO. |
|
|
`---------------------------*/
|
|
|
|
static void
|
|
yy_symbol_print (FILE *yyo,
|
|
yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
|
|
{
|
|
YYFPRINTF (yyo, "%s %s (",
|
|
yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
|
|
|
|
yy_symbol_value_print (yyo, yykind, yyvaluep, yyscanner);
|
|
YYFPRINTF (yyo, ")");
|
|
}
|
|
|
|
/*------------------------------------------------------------------.
|
|
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
|
|
| TOP (included). |
|
|
`------------------------------------------------------------------*/
|
|
|
|
static void
|
|
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
|
|
{
|
|
YYFPRINTF (stderr, "Stack now");
|
|
for (; yybottom <= yytop; yybottom++)
|
|
{
|
|
int yybot = *yybottom;
|
|
YYFPRINTF (stderr, " %d", yybot);
|
|
}
|
|
YYFPRINTF (stderr, "\n");
|
|
}
|
|
|
|
# define YY_STACK_PRINT(Bottom, Top) \
|
|
do { \
|
|
if (yydebug) \
|
|
yy_stack_print ((Bottom), (Top)); \
|
|
} while (0)
|
|
|
|
|
|
/*------------------------------------------------.
|
|
| Report that the YYRULE is going to be reduced. |
|
|
`------------------------------------------------*/
|
|
|
|
static void
|
|
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
|
|
int yyrule, yyscan_t yyscanner)
|
|
{
|
|
int yylno = yyrline[yyrule];
|
|
int yynrhs = yyr2[yyrule];
|
|
int yyi;
|
|
YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
|
|
yyrule - 1, yylno);
|
|
/* The symbols being reduced. */
|
|
for (yyi = 0; yyi < yynrhs; yyi++)
|
|
{
|
|
YYFPRINTF (stderr, " $%d = ", yyi + 1);
|
|
yy_symbol_print (stderr,
|
|
YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
|
|
&yyvsp[(yyi + 1) - (yynrhs)], yyscanner);
|
|
YYFPRINTF (stderr, "\n");
|
|
}
|
|
}
|
|
|
|
# define YY_REDUCE_PRINT(Rule) \
|
|
do { \
|
|
if (yydebug) \
|
|
yy_reduce_print (yyssp, yyvsp, Rule, yyscanner); \
|
|
} while (0)
|
|
|
|
/* Nonzero means print parse trace. It is left uninitialized so that
|
|
multiple parsers can coexist. */
|
|
int yydebug;
|
|
#else /* !YYDEBUG */
|
|
# define YYDPRINTF(Args) ((void) 0)
|
|
# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
|
|
# define YY_STACK_PRINT(Bottom, Top)
|
|
# define YY_REDUCE_PRINT(Rule)
|
|
#endif /* !YYDEBUG */
|
|
|
|
|
|
/* YYINITDEPTH -- initial size of the parser's stacks. */
|
|
#ifndef YYINITDEPTH
|
|
# define YYINITDEPTH 200
|
|
#endif
|
|
|
|
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
|
|
if the built-in stack extension method is used).
|
|
|
|
Do not make this value too large; the results are undefined if
|
|
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
|
|
evaluated with infinite-precision integer arithmetic. */
|
|
|
|
#ifndef YYMAXDEPTH
|
|
# define YYMAXDEPTH 10000
|
|
#endif
|
|
|
|
|
|
/* Context of a parse error. */
|
|
typedef struct
|
|
{
|
|
yy_state_t *yyssp;
|
|
yysymbol_kind_t yytoken;
|
|
} yypcontext_t;
|
|
|
|
/* Put in YYARG at most YYARGN of the expected tokens given the
|
|
current YYCTX, and return the number of tokens stored in YYARG. If
|
|
YYARG is null, return the number of expected tokens (guaranteed to
|
|
be less than YYNTOKENS). Return YYENOMEM on memory exhaustion.
|
|
Return 0 if there are more than YYARGN expected tokens, yet fill
|
|
YYARG up to YYARGN. */
|
|
static int
|
|
yypcontext_expected_tokens (const yypcontext_t *yyctx,
|
|
yysymbol_kind_t yyarg[], int yyargn)
|
|
{
|
|
/* Actual size of YYARG. */
|
|
int yycount = 0;
|
|
int yyn = yypact[+*yyctx->yyssp];
|
|
if (!yypact_value_is_default (yyn))
|
|
{
|
|
/* Start YYX at -YYN if negative to avoid negative indexes in
|
|
YYCHECK. In other words, skip the first -YYN actions for
|
|
this state because they are default actions. */
|
|
int yyxbegin = yyn < 0 ? -yyn : 0;
|
|
/* Stay within bounds of both yycheck and yytname. */
|
|
int yychecklim = YYLAST - yyn + 1;
|
|
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
|
|
int yyx;
|
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
|
|
if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror
|
|
&& !yytable_value_is_error (yytable[yyx + yyn]))
|
|
{
|
|
if (!yyarg)
|
|
++yycount;
|
|
else if (yycount == yyargn)
|
|
return 0;
|
|
else
|
|
yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
|
|
}
|
|
}
|
|
if (yyarg && yycount == 0 && 0 < yyargn)
|
|
yyarg[0] = YYSYMBOL_YYEMPTY;
|
|
return yycount;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifndef yystrlen
|
|
# if defined __GLIBC__ && defined _STRING_H
|
|
# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
|
|
# else
|
|
/* Return the length of YYSTR. */
|
|
static YYPTRDIFF_T
|
|
yystrlen (const char *yystr)
|
|
{
|
|
YYPTRDIFF_T yylen;
|
|
for (yylen = 0; yystr[yylen]; yylen++)
|
|
continue;
|
|
return yylen;
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef yystpcpy
|
|
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
|
|
# define yystpcpy stpcpy
|
|
# else
|
|
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
|
|
YYDEST. */
|
|
static char *
|
|
yystpcpy (char *yydest, const char *yysrc)
|
|
{
|
|
char *yyd = yydest;
|
|
const char *yys = yysrc;
|
|
|
|
while ((*yyd++ = *yys++) != '\0')
|
|
continue;
|
|
|
|
return yyd - 1;
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef yytnamerr
|
|
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
|
|
quotes and backslashes, so that it's suitable for yyerror. The
|
|
heuristic is that double-quoting is unnecessary unless the string
|
|
contains an apostrophe, a comma, or backslash (other than
|
|
backslash-backslash). YYSTR is taken from yytname. If YYRES is
|
|
null, do not copy; instead, return the length of what the result
|
|
would have been. */
|
|
static YYPTRDIFF_T
|
|
yytnamerr (char *yyres, const char *yystr)
|
|
{
|
|
if (*yystr == '"')
|
|
{
|
|
YYPTRDIFF_T yyn = 0;
|
|
char const *yyp = yystr;
|
|
for (;;)
|
|
switch (*++yyp)
|
|
{
|
|
case '\'':
|
|
case ',':
|
|
goto do_not_strip_quotes;
|
|
|
|
case '\\':
|
|
if (*++yyp != '\\')
|
|
goto do_not_strip_quotes;
|
|
else
|
|
goto append;
|
|
|
|
append:
|
|
default:
|
|
if (yyres)
|
|
yyres[yyn] = *yyp;
|
|
yyn++;
|
|
break;
|
|
|
|
case '"':
|
|
if (yyres)
|
|
yyres[yyn] = '\0';
|
|
return yyn;
|
|
}
|
|
do_not_strip_quotes: ;
|
|
}
|
|
|
|
if (yyres)
|
|
return yystpcpy (yyres, yystr) - yyres;
|
|
else
|
|
return yystrlen (yystr);
|
|
}
|
|
#endif
|
|
|
|
|
|
static int
|
|
yy_syntax_error_arguments (const yypcontext_t *yyctx,
|
|
yysymbol_kind_t yyarg[], int yyargn)
|
|
{
|
|
/* Actual size of YYARG. */
|
|
int yycount = 0;
|
|
/* There are many possibilities here to consider:
|
|
- If this state is a consistent state with a default action, then
|
|
the only way this function was invoked is if the default action
|
|
is an error action. In that case, don't check for expected
|
|
tokens because there are none.
|
|
- The only way there can be no lookahead present (in yychar) is if
|
|
this state is a consistent state with a default action. Thus,
|
|
detecting the absence of a lookahead is sufficient to determine
|
|
that there is no unexpected or expected token to report. In that
|
|
case, just report a simple "syntax error".
|
|
- Don't assume there isn't a lookahead just because this state is a
|
|
consistent state with a default action. There might have been a
|
|
previous inconsistent state, consistent state with a non-default
|
|
action, or user semantic action that manipulated yychar.
|
|
- Of course, the expected token list depends on states to have
|
|
correct lookahead information, and it depends on the parser not
|
|
to perform extra reductions after fetching a lookahead from the
|
|
scanner and before detecting a syntax error. Thus, state merging
|
|
(from LALR or IELR) and default reductions corrupt the expected
|
|
token list. However, the list is correct for canonical LR with
|
|
one exception: it will still contain any token that will not be
|
|
accepted due to an error action in a later state.
|
|
*/
|
|
if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
|
|
{
|
|
int yyn;
|
|
if (yyarg)
|
|
yyarg[yycount] = yyctx->yytoken;
|
|
++yycount;
|
|
yyn = yypcontext_expected_tokens (yyctx,
|
|
yyarg ? yyarg + 1 : yyarg, yyargn - 1);
|
|
if (yyn == YYENOMEM)
|
|
return YYENOMEM;
|
|
else
|
|
yycount += yyn;
|
|
}
|
|
return yycount;
|
|
}
|
|
|
|
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
|
|
about the unexpected token YYTOKEN for the state stack whose top is
|
|
YYSSP.
|
|
|
|
Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is
|
|
not large enough to hold the message. In that case, also set
|
|
*YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the
|
|
required number of bytes is too large to store. */
|
|
static int
|
|
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
|
|
const yypcontext_t *yyctx)
|
|
{
|
|
enum { YYARGS_MAX = 5 };
|
|
/* Internationalized format string. */
|
|
const char *yyformat = YY_NULLPTR;
|
|
/* Arguments of yyformat: reported tokens (one for the "unexpected",
|
|
one per "expected"). */
|
|
yysymbol_kind_t yyarg[YYARGS_MAX];
|
|
/* Cumulated lengths of YYARG. */
|
|
YYPTRDIFF_T yysize = 0;
|
|
|
|
/* Actual size of YYARG. */
|
|
int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX);
|
|
if (yycount == YYENOMEM)
|
|
return YYENOMEM;
|
|
|
|
switch (yycount)
|
|
{
|
|
#define YYCASE_(N, S) \
|
|
case N: \
|
|
yyformat = S; \
|
|
break
|
|
default: /* Avoid compiler warnings. */
|
|
YYCASE_(0, YY_("syntax error"));
|
|
YYCASE_(1, YY_("syntax error, unexpected %s"));
|
|
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
|
|
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
|
|
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
|
|
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
|
|
#undef YYCASE_
|
|
}
|
|
|
|
/* Compute error message size. Don't count the "%s"s, but reserve
|
|
room for the terminator. */
|
|
yysize = yystrlen (yyformat) - 2 * yycount + 1;
|
|
{
|
|
int yyi;
|
|
for (yyi = 0; yyi < yycount; ++yyi)
|
|
{
|
|
YYPTRDIFF_T yysize1
|
|
= yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]);
|
|
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
|
|
yysize = yysize1;
|
|
else
|
|
return YYENOMEM;
|
|
}
|
|
}
|
|
|
|
if (*yymsg_alloc < yysize)
|
|
{
|
|
*yymsg_alloc = 2 * yysize;
|
|
if (! (yysize <= *yymsg_alloc
|
|
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
|
|
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
|
|
return -1;
|
|
}
|
|
|
|
/* Avoid sprintf, as that infringes on the user's name space.
|
|
Don't have undefined behavior even if the translation
|
|
produced a string with the wrong number of "%s"s. */
|
|
{
|
|
char *yyp = *yymsg;
|
|
int yyi = 0;
|
|
while ((*yyp = *yyformat) != '\0')
|
|
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
|
|
{
|
|
yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);
|
|
yyformat += 2;
|
|
}
|
|
else
|
|
{
|
|
++yyp;
|
|
++yyformat;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------.
|
|
| Release the memory associated to this symbol. |
|
|
`-----------------------------------------------*/
|
|
|
|
static void
|
|
yydestruct (const char *yymsg,
|
|
yysymbol_kind_t yykind, YYSTYPE *yyvaluep, yyscan_t yyscanner)
|
|
{
|
|
YY_USE (yyvaluep);
|
|
YY_USE (yyscanner);
|
|
if (!yymsg)
|
|
yymsg = "Deleting";
|
|
YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
|
|
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
switch (yykind)
|
|
{
|
|
case YYSYMBOL_STRING: /* STRING */
|
|
#line 100 "cmFortranParser.y"
|
|
{ free(((*yyvaluep).string)); }
|
|
#line 1333 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case YYSYMBOL_WORD: /* WORD */
|
|
#line 100 "cmFortranParser.y"
|
|
{ free(((*yyvaluep).string)); }
|
|
#line 1339 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case YYSYMBOL_CPP_INCLUDE_ANGLE: /* CPP_INCLUDE_ANGLE */
|
|
#line 100 "cmFortranParser.y"
|
|
{ free(((*yyvaluep).string)); }
|
|
#line 1345 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*----------.
|
|
| yyparse. |
|
|
`----------*/
|
|
|
|
int
|
|
yyparse (yyscan_t yyscanner)
|
|
{
|
|
/* Lookahead token kind. */
|
|
int yychar;
|
|
|
|
|
|
/* The semantic value of the lookahead symbol. */
|
|
/* Default value used for initialization, for pacifying older GCCs
|
|
or non-GCC compilers. */
|
|
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
|
|
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
|
|
|
|
/* Number of syntax errors so far. */
|
|
int yynerrs = 0;
|
|
|
|
yy_state_fast_t yystate = 0;
|
|
/* Number of tokens to shift before error messages enabled. */
|
|
int yyerrstatus = 0;
|
|
|
|
/* Refer to the stacks through separate pointers, to allow yyoverflow
|
|
to reallocate them elsewhere. */
|
|
|
|
/* Their size. */
|
|
YYPTRDIFF_T yystacksize = YYINITDEPTH;
|
|
|
|
/* The state stack: array, bottom, top. */
|
|
yy_state_t yyssa[YYINITDEPTH];
|
|
yy_state_t *yyss = yyssa;
|
|
yy_state_t *yyssp = yyss;
|
|
|
|
/* The semantic value stack: array, bottom, top. */
|
|
YYSTYPE yyvsa[YYINITDEPTH];
|
|
YYSTYPE *yyvs = yyvsa;
|
|
YYSTYPE *yyvsp = yyvs;
|
|
|
|
int yyn;
|
|
/* The return value of yyparse. */
|
|
int yyresult;
|
|
/* Lookahead symbol kind. */
|
|
yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
|
|
/* The variables used to return semantic value and location from the
|
|
action routines. */
|
|
YYSTYPE yyval;
|
|
|
|
/* Buffer for error messages, and its allocated size. */
|
|
char yymsgbuf[128];
|
|
char *yymsg = yymsgbuf;
|
|
YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
|
|
|
|
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
|
|
|
|
/* The number of symbols on the RHS of the reduced rule.
|
|
Keep to zero when no symbol should be popped. */
|
|
int yylen = 0;
|
|
|
|
YYDPRINTF ((stderr, "Starting parse\n"));
|
|
|
|
yychar = YYEMPTY; /* Cause a token to be read. */
|
|
|
|
goto yysetstate;
|
|
|
|
|
|
/*------------------------------------------------------------.
|
|
| yynewstate -- push a new state, which is found in yystate. |
|
|
`------------------------------------------------------------*/
|
|
yynewstate:
|
|
/* In all cases, when you get here, the value and location stacks
|
|
have just been pushed. So pushing a state here evens the stacks. */
|
|
yyssp++;
|
|
|
|
|
|
/*--------------------------------------------------------------------.
|
|
| yysetstate -- set current state (the top of the stack) to yystate. |
|
|
`--------------------------------------------------------------------*/
|
|
yysetstate:
|
|
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
|
|
YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
|
|
YY_IGNORE_USELESS_CAST_BEGIN
|
|
*yyssp = YY_CAST (yy_state_t, yystate);
|
|
YY_IGNORE_USELESS_CAST_END
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
|
|
if (yyss + yystacksize - 1 <= yyssp)
|
|
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
|
|
YYNOMEM;
|
|
#else
|
|
{
|
|
/* Get the current used size of the three stacks, in elements. */
|
|
YYPTRDIFF_T yysize = yyssp - yyss + 1;
|
|
|
|
# if defined yyoverflow
|
|
{
|
|
/* Give user a chance to reallocate the stack. Use copies of
|
|
these so that the &'s don't force the real ones into
|
|
memory. */
|
|
yy_state_t *yyss1 = yyss;
|
|
YYSTYPE *yyvs1 = yyvs;
|
|
|
|
/* Each stack pointer address is followed by the size of the
|
|
data in use in that stack, in bytes. This used to be a
|
|
conditional around just the two extra args, but that might
|
|
be undefined if yyoverflow is a macro. */
|
|
yyoverflow (YY_("memory exhausted"),
|
|
&yyss1, yysize * YYSIZEOF (*yyssp),
|
|
&yyvs1, yysize * YYSIZEOF (*yyvsp),
|
|
&yystacksize);
|
|
yyss = yyss1;
|
|
yyvs = yyvs1;
|
|
}
|
|
# else /* defined YYSTACK_RELOCATE */
|
|
/* Extend the stack our own way. */
|
|
if (YYMAXDEPTH <= yystacksize)
|
|
YYNOMEM;
|
|
yystacksize *= 2;
|
|
if (YYMAXDEPTH < yystacksize)
|
|
yystacksize = YYMAXDEPTH;
|
|
|
|
{
|
|
yy_state_t *yyss1 = yyss;
|
|
union yyalloc *yyptr =
|
|
YY_CAST (union yyalloc *,
|
|
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
|
|
if (! yyptr)
|
|
YYNOMEM;
|
|
YYSTACK_RELOCATE (yyss_alloc, yyss);
|
|
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
|
|
# undef YYSTACK_RELOCATE
|
|
if (yyss1 != yyssa)
|
|
YYSTACK_FREE (yyss1);
|
|
}
|
|
# endif
|
|
|
|
yyssp = yyss + yysize - 1;
|
|
yyvsp = yyvs + yysize - 1;
|
|
|
|
YY_IGNORE_USELESS_CAST_BEGIN
|
|
YYDPRINTF ((stderr, "Stack size increased to %ld\n",
|
|
YY_CAST (long, yystacksize)));
|
|
YY_IGNORE_USELESS_CAST_END
|
|
|
|
if (yyss + yystacksize - 1 <= yyssp)
|
|
YYABORT;
|
|
}
|
|
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
|
|
|
|
|
|
if (yystate == YYFINAL)
|
|
YYACCEPT;
|
|
|
|
goto yybackup;
|
|
|
|
|
|
/*-----------.
|
|
| yybackup. |
|
|
`-----------*/
|
|
yybackup:
|
|
/* Do appropriate processing given the current state. Read a
|
|
lookahead token if we need one and don't already have one. */
|
|
|
|
/* First try to decide what to do without reference to lookahead token. */
|
|
yyn = yypact[yystate];
|
|
if (yypact_value_is_default (yyn))
|
|
goto yydefault;
|
|
|
|
/* Not known => get a lookahead token if don't already have one. */
|
|
|
|
/* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
|
|
if (yychar == YYEMPTY)
|
|
{
|
|
YYDPRINTF ((stderr, "Reading a token\n"));
|
|
yychar = yylex (&yylval, yyscanner);
|
|
}
|
|
|
|
if (yychar <= YYEOF)
|
|
{
|
|
yychar = YYEOF;
|
|
yytoken = YYSYMBOL_YYEOF;
|
|
YYDPRINTF ((stderr, "Now at end of input.\n"));
|
|
}
|
|
else if (yychar == YYerror)
|
|
{
|
|
/* The scanner already issued an error message, process directly
|
|
to error recovery. But do not keep the error token as
|
|
lookahead, it is too special and may lead us to an endless
|
|
loop in error recovery. */
|
|
yychar = YYUNDEF;
|
|
yytoken = YYSYMBOL_YYerror;
|
|
goto yyerrlab1;
|
|
}
|
|
else
|
|
{
|
|
yytoken = YYTRANSLATE (yychar);
|
|
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
|
|
}
|
|
|
|
/* If the proper action on seeing token YYTOKEN is to reduce or to
|
|
detect an error, take that action. */
|
|
yyn += yytoken;
|
|
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
|
|
goto yydefault;
|
|
yyn = yytable[yyn];
|
|
if (yyn <= 0)
|
|
{
|
|
if (yytable_value_is_error (yyn))
|
|
goto yyerrlab;
|
|
yyn = -yyn;
|
|
goto yyreduce;
|
|
}
|
|
|
|
/* Count tokens shifted since error; after three, turn off error
|
|
status. */
|
|
if (yyerrstatus)
|
|
yyerrstatus--;
|
|
|
|
/* Shift the lookahead token. */
|
|
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
|
|
yystate = yyn;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
*++yyvsp = yylval;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
|
|
/* Discard the shifted token. */
|
|
yychar = YYEMPTY;
|
|
goto yynewstate;
|
|
|
|
|
|
/*-----------------------------------------------------------.
|
|
| yydefault -- do the default action for the current state. |
|
|
`-----------------------------------------------------------*/
|
|
yydefault:
|
|
yyn = yydefact[yystate];
|
|
if (yyn == 0)
|
|
goto yyerrlab;
|
|
goto yyreduce;
|
|
|
|
|
|
/*-----------------------------.
|
|
| yyreduce -- do a reduction. |
|
|
`-----------------------------*/
|
|
yyreduce:
|
|
/* yyn is the number of a rule to reduce with. */
|
|
yylen = yyr2[yyn];
|
|
|
|
/* If YYLEN is nonzero, implement the default value of the action:
|
|
'$$ = $1'.
|
|
|
|
Otherwise, the following line sets YYVAL to garbage.
|
|
This behavior is undocumented and Bison
|
|
users should not rely upon it. Assigning to YYVAL
|
|
unconditionally makes the parser a bit smaller, and it avoids a
|
|
GCC warning that YYVAL may be used uninitialized. */
|
|
yyval = yyvsp[1-yylen];
|
|
|
|
|
|
YY_REDUCE_PRINT (yyn);
|
|
switch (yyn)
|
|
{
|
|
case 4: /* stmt: INTERFACE EOSTMT */
|
|
#line 109 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_SetInInterface(parser, true);
|
|
}
|
|
#line 1627 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 5: /* stmt: USE WORD other EOSTMT */
|
|
#line 113 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1637 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 6: /* stmt: MODULE WORD EOSTMT */
|
|
#line 118 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleModule(parser, (yyvsp[-1].string));
|
|
free((yyvsp[-1].string));
|
|
}
|
|
#line 1647 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 7: /* stmt: SUBMODULE LPAREN WORD RPAREN WORD EOSTMT */
|
|
#line 123 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleSubmodule(parser, (yyvsp[-3].string), (yyvsp[-1].string));
|
|
free((yyvsp[-3].string));
|
|
free((yyvsp[-1].string));
|
|
}
|
|
#line 1658 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 8: /* stmt: SUBMODULE LPAREN WORD COLON WORD RPAREN WORD EOSTMT */
|
|
#line 129 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleSubmoduleNested(parser, (yyvsp[-5].string), (yyvsp[-3].string), (yyvsp[-1].string));
|
|
free((yyvsp[-5].string));
|
|
free((yyvsp[-3].string));
|
|
free((yyvsp[-1].string));
|
|
}
|
|
#line 1670 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 9: /* stmt: INTERFACE WORD EOSTMT */
|
|
#line 136 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_SetInInterface(parser, true);
|
|
free((yyvsp[-1].string));
|
|
}
|
|
#line 1680 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 10: /* stmt: END INTERFACE WORD EOSTMT */
|
|
#line 141 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_SetInInterface(parser, false);
|
|
free((yyvsp[-1].string));
|
|
}
|
|
#line 1690 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 11: /* stmt: END INTERFACE EOSTMT */
|
|
#line 146 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_SetInInterface(parser, false);
|
|
}
|
|
#line 1699 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 12: /* stmt: USE DCOLON WORD other EOSTMT */
|
|
#line 150 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1709 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 13: /* stmt: USE COMMA WORD DCOLON WORD other EOSTMT */
|
|
#line 155 "cmFortranParser.y"
|
|
{
|
|
if (cmsysString_strcasecmp((yyvsp[-4].string), "non_intrinsic") == 0) {
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
|
|
}
|
|
if (cmsysString_strcasecmp((yyvsp[-4].string), "intrinsic") == 0) {
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleUseIntrinsic(parser, (yyvsp[-2].string));
|
|
}
|
|
free((yyvsp[-4].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1726 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 14: /* stmt: INCLUDE STRING EOSTMT */
|
|
#line 167 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleInclude(parser, (yyvsp[-1].string));
|
|
free((yyvsp[-1].string));
|
|
}
|
|
#line 1736 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 15: /* stmt: CPP_LINE_DIRECTIVE STRING other EOSTMT */
|
|
#line 172 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleLineDirective(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1746 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 16: /* stmt: CPP_INCLUDE_ANGLE other EOSTMT */
|
|
#line 177 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1756 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 17: /* stmt: include STRING other EOSTMT */
|
|
#line 182 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1766 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 18: /* stmt: define WORD other EOSTMT */
|
|
#line 187 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleDefine(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1776 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 19: /* stmt: undef WORD other EOSTMT */
|
|
#line 192 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleUndef(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1786 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 20: /* stmt: ifdef WORD other EOSTMT */
|
|
#line 197 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleIfdef(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1796 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 21: /* stmt: ifndef WORD other EOSTMT */
|
|
#line 202 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleIfndef(parser, (yyvsp[-2].string));
|
|
free((yyvsp[-2].string));
|
|
}
|
|
#line 1806 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 22: /* stmt: if other EOSTMT */
|
|
#line 207 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleIf(parser);
|
|
}
|
|
#line 1815 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 23: /* stmt: elif other EOSTMT */
|
|
#line 211 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleElif(parser);
|
|
}
|
|
#line 1824 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 24: /* stmt: else other EOSTMT */
|
|
#line 215 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleElse(parser);
|
|
}
|
|
#line 1833 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 25: /* stmt: endif other EOSTMT */
|
|
#line 219 "cmFortranParser.y"
|
|
{
|
|
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
|
|
cmFortranParser_RuleEndif(parser);
|
|
}
|
|
#line 1842 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 49: /* misc_code: WORD */
|
|
#line 241 "cmFortranParser.y"
|
|
{ free ((yyvsp[0].string)); }
|
|
#line 1848 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
case 56: /* misc_code: STRING */
|
|
#line 248 "cmFortranParser.y"
|
|
{ free ((yyvsp[0].string)); }
|
|
#line 1854 "cmFortranParser.cxx"
|
|
break;
|
|
|
|
|
|
#line 1858 "cmFortranParser.cxx"
|
|
|
|
default: break;
|
|
}
|
|
/* User semantic actions sometimes alter yychar, and that requires
|
|
that yytoken be updated with the new translation. We take the
|
|
approach of translating immediately before every use of yytoken.
|
|
One alternative is translating here after every semantic action,
|
|
but that translation would be missed if the semantic action invokes
|
|
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
|
|
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
|
|
incorrect destructor might then be invoked immediately. In the
|
|
case of YYERROR or YYBACKUP, subsequent parser actions might lead
|
|
to an incorrect destructor call or verbose syntax error message
|
|
before the lookahead is translated. */
|
|
YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
|
|
|
|
YYPOPSTACK (yylen);
|
|
yylen = 0;
|
|
|
|
*++yyvsp = yyval;
|
|
|
|
/* Now 'shift' the result of the reduction. Determine what state
|
|
that goes to, based on the state we popped back to and the rule
|
|
number reduced by. */
|
|
{
|
|
const int yylhs = yyr1[yyn] - YYNTOKENS;
|
|
const int yyi = yypgoto[yylhs] + *yyssp;
|
|
yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
|
|
? yytable[yyi]
|
|
: yydefgoto[yylhs]);
|
|
}
|
|
|
|
goto yynewstate;
|
|
|
|
|
|
/*--------------------------------------.
|
|
| yyerrlab -- here on detecting error. |
|
|
`--------------------------------------*/
|
|
yyerrlab:
|
|
/* Make sure we have latest lookahead translation. See comments at
|
|
user semantic actions for why this is necessary. */
|
|
yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
|
|
/* If not already recovering from an error, report this error. */
|
|
if (!yyerrstatus)
|
|
{
|
|
++yynerrs;
|
|
{
|
|
yypcontext_t yyctx
|
|
= {yyssp, yytoken};
|
|
char const *yymsgp = YY_("syntax error");
|
|
int yysyntax_error_status;
|
|
yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
|
|
if (yysyntax_error_status == 0)
|
|
yymsgp = yymsg;
|
|
else if (yysyntax_error_status == -1)
|
|
{
|
|
if (yymsg != yymsgbuf)
|
|
YYSTACK_FREE (yymsg);
|
|
yymsg = YY_CAST (char *,
|
|
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
|
|
if (yymsg)
|
|
{
|
|
yysyntax_error_status
|
|
= yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
|
|
yymsgp = yymsg;
|
|
}
|
|
else
|
|
{
|
|
yymsg = yymsgbuf;
|
|
yymsg_alloc = sizeof yymsgbuf;
|
|
yysyntax_error_status = YYENOMEM;
|
|
}
|
|
}
|
|
yyerror (yyscanner, yymsgp);
|
|
if (yysyntax_error_status == YYENOMEM)
|
|
YYNOMEM;
|
|
}
|
|
}
|
|
|
|
if (yyerrstatus == 3)
|
|
{
|
|
/* If just tried and failed to reuse lookahead token after an
|
|
error, discard it. */
|
|
|
|
if (yychar <= YYEOF)
|
|
{
|
|
/* Return failure if at end of input. */
|
|
if (yychar == YYEOF)
|
|
YYABORT;
|
|
}
|
|
else
|
|
{
|
|
yydestruct ("Error: discarding",
|
|
yytoken, &yylval, yyscanner);
|
|
yychar = YYEMPTY;
|
|
}
|
|
}
|
|
|
|
/* Else will try to reuse lookahead token after shifting the error
|
|
token. */
|
|
goto yyerrlab1;
|
|
|
|
|
|
/*---------------------------------------------------.
|
|
| yyerrorlab -- error raised explicitly by YYERROR. |
|
|
`---------------------------------------------------*/
|
|
yyerrorlab:
|
|
/* Pacify compilers when the user code never invokes YYERROR and the
|
|
label yyerrorlab therefore never appears in user code. */
|
|
if (0)
|
|
YYERROR;
|
|
++yynerrs;
|
|
|
|
/* Do not reclaim the symbols of the rule whose action triggered
|
|
this YYERROR. */
|
|
YYPOPSTACK (yylen);
|
|
yylen = 0;
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
yystate = *yyssp;
|
|
goto yyerrlab1;
|
|
|
|
|
|
/*-------------------------------------------------------------.
|
|
| yyerrlab1 -- common code for both syntax error and YYERROR. |
|
|
`-------------------------------------------------------------*/
|
|
yyerrlab1:
|
|
yyerrstatus = 3; /* Each real token shifted decrements this. */
|
|
|
|
/* Pop stack until we find a state that shifts the error token. */
|
|
for (;;)
|
|
{
|
|
yyn = yypact[yystate];
|
|
if (!yypact_value_is_default (yyn))
|
|
{
|
|
yyn += YYSYMBOL_YYerror;
|
|
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
|
|
{
|
|
yyn = yytable[yyn];
|
|
if (0 < yyn)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Pop the current state because it cannot handle the error token. */
|
|
if (yyssp == yyss)
|
|
YYABORT;
|
|
|
|
|
|
yydestruct ("Error: popping",
|
|
YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner);
|
|
YYPOPSTACK (1);
|
|
yystate = *yyssp;
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
}
|
|
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
*++yyvsp = yylval;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
|
|
|
|
/* Shift the error token. */
|
|
YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
|
|
|
|
yystate = yyn;
|
|
goto yynewstate;
|
|
|
|
|
|
/*-------------------------------------.
|
|
| yyacceptlab -- YYACCEPT comes here. |
|
|
`-------------------------------------*/
|
|
yyacceptlab:
|
|
yyresult = 0;
|
|
goto yyreturnlab;
|
|
|
|
|
|
/*-----------------------------------.
|
|
| yyabortlab -- YYABORT comes here. |
|
|
`-----------------------------------*/
|
|
yyabortlab:
|
|
yyresult = 1;
|
|
goto yyreturnlab;
|
|
|
|
|
|
/*-----------------------------------------------------------.
|
|
| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
|
|
`-----------------------------------------------------------*/
|
|
yyexhaustedlab:
|
|
yyerror (yyscanner, YY_("memory exhausted"));
|
|
yyresult = 2;
|
|
goto yyreturnlab;
|
|
|
|
|
|
/*----------------------------------------------------------.
|
|
| yyreturnlab -- parsing is finished, clean up and return. |
|
|
`----------------------------------------------------------*/
|
|
yyreturnlab:
|
|
if (yychar != YYEMPTY)
|
|
{
|
|
/* Make sure we have latest lookahead translation. See comments at
|
|
user semantic actions for why this is necessary. */
|
|
yytoken = YYTRANSLATE (yychar);
|
|
yydestruct ("Cleanup: discarding lookahead",
|
|
yytoken, &yylval, yyscanner);
|
|
}
|
|
/* Do not reclaim the symbols of the rule whose action triggered
|
|
this YYABORT or YYACCEPT. */
|
|
YYPOPSTACK (yylen);
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
while (yyssp != yyss)
|
|
{
|
|
yydestruct ("Cleanup: popping",
|
|
YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner);
|
|
YYPOPSTACK (1);
|
|
}
|
|
#ifndef yyoverflow
|
|
if (yyss != yyssa)
|
|
YYSTACK_FREE (yyss);
|
|
#endif
|
|
if (yymsg != yymsgbuf)
|
|
YYSTACK_FREE (yymsg);
|
|
return yyresult;
|
|
}
|
|
|
|
#line 260 "cmFortranParser.y"
|
|
|
|
/* End of grammar */
|