"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "command.c" between
gawk-5.0.1.tar.xz and gawk-5.1.0.tar.xz

About: GNU awk - pattern scanning and processing language.

command.c  (gawk-5.0.1.tar.xz):command.c  (gawk-5.1.0.tar.xz)
/* A Bison parser, made by GNU Bison 3.4. */ /* A Bison parser, made by GNU Bison 3.5.4. */
/* Bison implementation for Yacc-like parsers in C /* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
Inc. Inc.
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
skipping to change at line 51 skipping to change at line 51
define necessary library symbols; they are noted "INFRINGES ON define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */ USER NAME SPACE" below. */
/* Undocumented macros, especially those whose name start with YY_, /* Undocumented macros, especially those whose name start with YY_,
are private implementation details. Do not rely on them. */ are private implementation details. Do not rely on them. */
/* Identify Bison output. */ /* Identify Bison output. */
#define YYBISON 1 #define YYBISON 1
/* Bison version. */ /* Bison version. */
#define YYBISON_VERSION "3.4" #define YYBISON_VERSION "3.5.4"
/* Skeleton name. */ /* Skeleton name. */
#define YYSKELETON_NAME "yacc.c" #define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */ /* Pure parsers. */
#define YYPURE 0 #define YYPURE 0
/* Push parsers. */ /* Push parsers. */
#define YYPUSH 0 #define YYPUSH 0
/* Pull parsers. */ /* Pull parsers. */
#define YYPULL 1 #define YYPULL 1
/* Substitute the variable and function names. */ /* Substitute the variable and function names. */
#define yyparse zzparse #define yyparse zzparse
#define yylex zzlex #define yylex zzlex
#define yyerror zzerror #define yyerror zzerror
#define yydebug zzdebug #define yydebug zzdebug
#define yynerrs zznerrs #define yynerrs zznerrs
#define yylval zzlval #define yylval zzlval
#define yychar zzchar #define yychar zzchar
/* First part of user prologue. */ /* First part of user prologue. */
#line 28 "command.y" #line 28 "command.y"
#include "awk.h" #include "awk.h"
#include "cmd.h" #include "cmd.h"
#if 0 #if 0
skipping to change at line 143 skipping to change at line 142
#define cmdtab zz_debug_cmdtab #define cmdtab zz_debug_cmdtab
extern struct argtoken argtab[]; extern struct argtoken argtab[];
extern struct cmdtoken cmdtab[]; extern struct cmdtoken cmdtab[];
static CMDARG *mk_cmdarg(enum argtype type); static CMDARG *mk_cmdarg(enum argtype type);
static void append_cmdarg(CMDARG *arg); static void append_cmdarg(CMDARG *arg);
static int find_argument(CMDARG *arg); static int find_argument(CMDARG *arg);
#define YYSTYPE CMDARG * #define YYSTYPE CMDARG *
#line 145 "command.c" #line 144 "command.c"
# 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 # ifndef YY_NULLPTR
# if defined __cplusplus # if defined __cplusplus
# if 201103L <= __cplusplus # if 201103L <= __cplusplus
# define YY_NULLPTR nullptr # define YY_NULLPTR nullptr
# else # else
# define YY_NULLPTR 0 # define YY_NULLPTR 0
# endif # endif
# else # else
# define YY_NULLPTR ((void*)0) # define YY_NULLPTR ((void*)0)
# endif # endif
skipping to change at line 289 skipping to change at line 297
#endif #endif
extern YYSTYPE zzlval; extern YYSTYPE zzlval;
int zzparse (void); int zzparse (void);
#ifdef short #ifdef short
# undef short # undef short
#endif #endif
#ifdef YYTYPE_UINT8 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
typedef YYTYPE_UINT8 yytype_uint8; <limits.h> and (if available) <stdint.h> are included
#else so that the code can choose integer types of a good width. */
typedef unsigned char yytype_uint8;
#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 #endif
#ifdef YYTYPE_INT8 /* Narrow types that promote to a signed type and that can represent a
typedef YYTYPE_INT8 yytype_int8; 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 #else
typedef signed char yytype_int8; typedef signed char yytype_int8;
#endif #endif
#ifdef YYTYPE_UINT16 #ifdef __INT_LEAST16_MAX__
typedef YYTYPE_UINT16 yytype_uint16; typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else #else
typedef unsigned short yytype_uint16; typedef short yytype_int16;
#endif #endif
#ifdef YYTYPE_INT16 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef YYTYPE_INT16 yytype_int16; 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 #else
typedef short yytype_int16; 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 #endif
#ifndef YYSIZE_T #ifndef YYSIZE_T
# ifdef __SIZE_TYPE__ # ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__ # define YYSIZE_T __SIZE_TYPE__
# elif defined size_t # elif defined size_t
# define YYSIZE_T size_t # define YYSIZE_T size_t
# elif ! defined YYSIZE_T # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t # define YYSIZE_T size_t
# else # else
# define YYSIZE_T unsigned # define YYSIZE_T unsigned
# endif # endif
#endif #endif
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #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_uint8 yy_state_t;
/* State numbers in computations. */
typedef int yy_state_fast_t;
#ifndef YY_ #ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS # if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS # if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid) # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif # endif
# endif # endif
# ifndef YY_ # ifndef YY_
# define YY_(Msgid) Msgid # define YY_(Msgid) Msgid
# endif # endif
#endif #endif
#ifndef YY_ATTRIBUTE #ifndef YY_ATTRIBUTE_PURE
# if (defined __GNUC__ \ # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
&& (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
|| defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
# else # else
# define YY_ATTRIBUTE(Spec) /* empty */ # define YY_ATTRIBUTE_PURE
# endif # endif
#endif #endif
#ifndef YY_ATTRIBUTE_PURE
# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
#endif
#ifndef YY_ATTRIBUTE_UNUSED #ifndef YY_ATTRIBUTE_UNUSED
# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
# define YY_ATTRIBUTE_UNUSED
# endif
#endif #endif
/* Suppress unused-variable warnings by "using" E. */ /* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__ #if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E)) # define YYUSE(E) ((void) (E))
#else #else
# define YYUSE(E) /* empty */ # define YYUSE(E) /* empty */
#endif #endif
#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR_ _ #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR_ _
/* Suppress an incorrect diagnostic about yylval being uninitialized. */ /* Suppress an incorrect diagnostic about yylval being uninitialized. */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ("GCC diagnostic push") \ _Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
_Pragma ("GCC diagnostic pop") _Pragma ("GCC diagnostic pop")
#else #else
# define YY_INITIAL_VALUE(Value) Value # define YY_INITIAL_VALUE(Value) Value
#endif #endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END # define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif #endif
#ifndef YY_INITIAL_VALUE #ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */ # define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif #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))) #define YY_ASSERT(E) ((void) (0 && (E)))
#if ! defined yyoverflow || YYERROR_VERBOSE #if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */ /* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA # ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA
# ifdef __GNUC__ # ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca # define YYSTACK_ALLOC __builtin_alloca
skipping to change at line 460 skipping to change at line 537
# endif # endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
#if (! defined yyoverflow \ #if (! defined yyoverflow \
&& (! defined __cplusplus \ && (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */ /* A type that is properly aligned for any stack member. */
union yyalloc union yyalloc
{ {
yytype_int16 yyss_alloc; yy_state_t yyss_alloc;
YYSTYPE yyvs_alloc; YYSTYPE yyvs_alloc;
}; };
/* The size of the maximum gap between one aligned stack and the next. */ /* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with /* The size of an array large to enough to hold all stacks, each with
N elements. */ N elements. */
# define YYSTACK_BYTES(N) \ # define YYSTACK_BYTES(N) \
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM) + YYSTACK_GAP_MAXIMUM)
# define YYCOPY_NEEDED 1 # define YYCOPY_NEEDED 1
/* Relocate STACK from its old location to the new one. The /* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next stack. Advance YYPTR to a properly aligned location for the next
stack. */ stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \ do \
{ \ { \
YYSIZE_T yynewbytes; \ YYPTRDIFF_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \ Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \ yyptr += yynewbytes / YYSIZEOF (*yyptr); \
} \ } \
while (0) while (0)
#endif #endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do /* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */ not overlap. */
# ifndef YYCOPY # ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__ # if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \ # define YYCOPY(Dst, Src, Count) \
__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
# else # else
# define YYCOPY(Dst, Src, Count) \ # define YYCOPY(Dst, Src, Count) \
do \ do \
{ \ { \
YYSIZE_T yyi; \ YYPTRDIFF_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \ for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \ (Dst)[yyi] = (Src)[yyi]; \
} \ } \
while (0) while (0)
# endif # endif
# endif # endif
#endif /* !YYCOPY_NEEDED */ #endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */ /* YYFINAL -- State number of the termination state. */
#define YYFINAL 2 #define YYFINAL 2
skipping to change at line 533 skipping to change at line 610
#define YYNRULES 156 #define YYNRULES 156
/* YYNSTATES -- Number of states. */ /* YYNSTATES -- Number of states. */
#define YYNSTATES 203 #define YYNSTATES 203
#define YYUNDEFTOK 2 #define YYUNDEFTOK 2
#define YYMAXUTOK 303 #define YYMAXUTOK 303
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
as returned by yylex, with out-of-bounds checking. */ as returned by yylex, with out-of-bounds checking. */
#define YYTRANSLATE(YYX) \ #define YYTRANSLATE(YYX) \
((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
as returned by yylex. */ as returned by yylex. */
static const yytype_uint8 yytranslate[] = static const yytype_int8 yytranslate[] =
{ {
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
58, 2, 2, 2, 2, 2, 2, 2, 2, 2, 58, 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, 57, 2, 2, 2, 2, 2, 2, 2, 2, 2, 57, 2, 2, 2,
2, 2, 2, 53, 50, 54, 2, 2, 2, 2, 2, 2, 2, 53, 50, 54, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 51, 2, 2, 2, 2, 2, 2, 2, 2, 2, 51, 2,
2, 49, 2, 2, 52, 2, 2, 2, 2, 2, 2, 49, 2, 2, 52, 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,
skipping to change at line 574 skipping to change at line 651
2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48 45, 46, 47, 48
}; };
#if YYDEBUG #if YYDEBUG
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] = static const yytype_int16 yyrline[] =
{ {
0, 109, 109, 110, 128, 129, 179, 186, 187, 188, 0, 109, 109, 110, 128, 129, 179, 186, 187, 188,
189, 190, 194, 195, 196, 197, 201, 202, 203, 204, 189, 190, 194, 195, 196, 197, 201, 202, 203, 204,
208, 209, 214, 218, 238, 245, 245, 252, 268, 282, 208, 209, 214, 218, 238, 245, 245, 252, 268, 282,
283, 284, 285, 286, 287, 293, 305, 306, 307, 307, 283, 284, 285, 286, 287, 293, 305, 306, 307, 307,
308, 308, 309, 310, 311, 312, 313, 313, 314, 315, 308, 308, 309, 310, 311, 312, 313, 313, 314, 315,
315, 316, 316, 317, 317, 318, 319, 320, 325, 330, 315, 316, 316, 317, 317, 318, 319, 320, 325, 330,
356, 366, 371, 383, 383, 391, 405, 418, 419, 425, 356, 366, 371, 383, 383, 391, 405, 418, 419, 425,
426, 430, 431, 432, 433, 439, 440, 441, 446, 457, 426, 430, 431, 432, 433, 439, 440, 441, 446, 457,
458, 463, 471, 488, 489, 490, 491, 492, 497, 498, 458, 463, 471, 488, 489, 490, 491, 492, 497, 498,
skipping to change at line 626 skipping to change at line 703
"printf_args", "list_args", "integer_range", "opt_integer_list", "printf_args", "list_args", "integer_range", "opt_integer_list",
"integer_list", "exp_list", "subscript", "subscript_list", "variable", "integer_list", "exp_list", "subscript", "subscript_list", "variable",
"node", "opt_plus_integer", "opt_integer", "plus_integer", "integer", "node", "opt_plus_integer", "opt_integer", "plus_integer", "integer",
"nls", YY_NULLPTR "nls", YY_NULLPTR
}; };
#endif #endif
# ifdef YYPRINT # ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the /* YYTOKNUM[NUM] -- (External) token number corresponding to the
(internal) symbol number NUM (which must be that of a token). */ (internal) symbol number NUM (which must be that of a token). */
static const yytype_uint16 yytoknum[] = static const yytype_int16 yytoknum[] =
{ {
0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
295, 296, 297, 298, 299, 300, 301, 302, 303, 61, 295, 296, 297, 298, 299, 300, 301, 302, 303, 61,
44, 58, 64, 43, 45, 91, 93, 36, 10 44, 58, 64, 43, 45, 91, 93, 36, 10
}; };
# endif # endif
#define YYPACT_NINF -151 #define YYPACT_NINF (-151)
#define yypact_value_is_default(Yystate) \ #define yypact_value_is_default(Yyn) \
(!!((Yystate) == (-151))) ((Yyn) == YYPACT_NINF)
#define YYTABLE_NINF -148 #define YYTABLE_NINF (-148)
#define yytable_value_is_error(Yytable_value) \ #define yytable_value_is_error(Yyn) \
0 0
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */ STATE-NUM. */
static const yytype_int16 yypact[] = static const yytype_int16 yypact[] =
{ {
-151, 145, -151, -34, -151, -151, 50, -151, -151, -151, -151, 145, -151, -34, -151, -151, 50, -151, -151, -151,
-151, 10, -151, -151, -10, 59, -9, 43, -151, -151, -151, 10, -151, -151, -10, 59, -9, 43, -151, -151,
-151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151,
50, -151, -151, -151, -151, -8, -6, 14, 12, -151, 50, -151, -151, -151, -151, -8, -6, 14, 12, -151,
skipping to change at line 779 skipping to change at line 856
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, -1, -1, 186, -1, 40, 41, 42, 43, 44, 35, -1, -1, 186, -1, 40, 41, 42, 43, 44,
45, 46, 47, -1, -1, -1, -1, -1, -1, -1, 45, 46, 47, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 58 -1, -1, -1, 58
}; };
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */ symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] = static const yytype_int8 yystos[] =
{ {
0, 60, 0, 1, 3, 4, 5, 6, 7, 8, 0, 60, 0, 1, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 40, 41, 42, 29, 30, 31, 32, 33, 34, 35, 40, 41, 42,
43, 44, 45, 46, 47, 58, 61, 62, 63, 64, 43, 44, 45, 46, 47, 58, 61, 62, 63, 64,
65, 67, 70, 71, 113, 113, 36, 37, 53, 86, 65, 67, 70, 71, 113, 113, 36, 37, 53, 86,
87, 111, 1, 37, 95, 101, 102, 103, 111, 37, 87, 111, 1, 37, 95, 101, 102, 103, 111, 37,
94, 111, 37, 37, 53, 54, 86, 100, 101, 111, 94, 111, 37, 37, 53, 54, 86, 100, 101, 111,
72, 73, 75, 74, 87, 76, 77, 37, 92, 37, 72, 73, 75, 74, 87, 76, 77, 37, 92, 37,
skipping to change at line 805 skipping to change at line 882
107, 107, 49, 1, 38, 39, 81, 82, 84, 78, 107, 107, 49, 1, 38, 39, 81, 82, 84, 78,
36, 36, 51, 89, 42, 48, 37, 86, 111, 111, 36, 36, 51, 89, 42, 48, 37, 86, 111, 111,
86, 101, 111, 55, 105, 106, 39, 38, 50, 96, 86, 101, 111, 55, 105, 106, 39, 38, 50, 96,
50, 38, 38, 49, 1, 79, 83, 84, 37, 113, 50, 38, 38, 49, 1, 79, 83, 84, 37, 113,
39, 50, 79, 86, 111, 79, 69, 1, 104, 108, 39, 50, 79, 86, 111, 79, 69, 1, 104, 108,
105, 106, 96, 98, 108, 39, 90, 113, 1, 50, 105, 106, 96, 98, 108, 39, 90, 113, 1, 50,
56, 79, 108 56, 79, 108
}; };
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint8 yyr1[] = static const yytype_int8 yyr1[] =
{ {
0, 59, 60, 60, 61, 61, 61, 62, 62, 62, 0, 59, 60, 60, 61, 61, 61, 62, 62, 62,
62, 62, 63, 63, 63, 63, 64, 64, 64, 64, 62, 62, 63, 63, 63, 63, 64, 64, 64, 64,
65, 65, 66, 67, 68, 69, 68, 70, 70, 71, 65, 65, 66, 67, 68, 69, 68, 70, 70, 71,
71, 71, 71, 71, 71, 71, 71, 71, 72, 71, 71, 71, 71, 71, 71, 71, 71, 71, 72, 71,
73, 71, 71, 71, 71, 71, 74, 71, 71, 75, 73, 71, 71, 71, 71, 71, 74, 71, 71, 75,
71, 76, 71, 77, 71, 71, 71, 71, 71, 71, 71, 76, 71, 77, 71, 71, 71, 71, 71, 71,
71, 71, 71, 78, 71, 71, 79, 80, 80, 81, 71, 71, 71, 78, 71, 71, 79, 80, 80, 81,
81, 82, 82, 82, 82, 83, 83, 83, 84, 85, 81, 82, 82, 82, 82, 83, 83, 83, 84, 85,
85, 85, 86, 87, 87, 87, 87, 87, 88, 89, 85, 85, 86, 87, 87, 87, 87, 87, 88, 89,
88, 88, 90, 88, 88, 91, 91, 92, 92, 93, 88, 88, 90, 88, 88, 91, 91, 92, 92, 93,
93, 94, 94, 95, 95, 96, 96, 96, 97, 97, 93, 94, 94, 95, 95, 96, 96, 96, 97, 97,
97, 97, 98, 98, 99, 99, 99, 100, 100, 100, 97, 97, 98, 98, 99, 99, 99, 100, 100, 100,
100, 100, 100, 100, 100, 100, 101, 102, 102, 102, 100, 100, 100, 100, 100, 100, 101, 102, 102, 102,
103, 103, 103, 103, 104, 104, 104, 105, 105, 106, 103, 103, 103, 103, 104, 104, 104, 105, 105, 106,
106, 107, 107, 107, 108, 108, 108, 109, 109, 110, 106, 107, 107, 107, 108, 108, 108, 109, 109, 110,
110, 111, 111, 112, 112, 112, 113 110, 111, 111, 112, 112, 112, 113
}; };
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
static const yytype_uint8 yyr2[] = static const yytype_int8 yyr2[] =
{ {
0, 2, 0, 2, 1, 2, 2, 1, 1, 1, 0, 2, 0, 2, 1, 2, 2, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 0, 4, 0, 0, 4, 3, 3, 2, 1, 1, 0, 4, 0, 0, 4, 3, 3, 2,
1, 1, 1, 2, 2, 2, 3, 2, 0, 3, 1, 1, 1, 2, 2, 2, 3, 2, 0, 3,
0, 3, 2, 2, 2, 2, 0, 5, 2, 0, 0, 3, 2, 2, 2, 2, 0, 5, 2, 0,
3, 0, 3, 0, 4, 2, 2, 2, 2, 2, 3, 0, 3, 0, 4, 2, 2, 2, 2, 2,
1, 1, 2, 0, 4, 1, 1, 1, 1, 0, 1, 1, 2, 0, 4, 1, 1, 1, 1, 0,
1, 1, 2, 3, 1, 0, 1, 1, 1, 0, 1, 1, 2, 3, 1, 0, 1, 1, 1, 0,
1, 3, 1, 0, 1, 1, 3, 3, 0, 0, 1, 3, 1, 0, 1, 1, 3, 3, 0, 0,
skipping to change at line 923 skipping to change at line 1000
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep) yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
{ {
FILE *yyoutput = yyo; FILE *yyoutput = yyo;
YYUSE (yyoutput); YYUSE (yyoutput);
if (!yyvaluep) if (!yyvaluep)
return; return;
# ifdef YYPRINT # ifdef YYPRINT
if (yytype < YYNTOKENS) if (yytype < YYNTOKENS)
YYPRINT (yyo, yytoknum[yytype], *yyvaluep); YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif # endif
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
YYUSE (yytype); YYUSE (yytype);
YY_IGNORE_MAYBE_UNINITIALIZED_END
} }
/*---------------------------. /*---------------------------.
| Print this symbol on YYO. | | Print this symbol on YYO. |
`---------------------------*/ `---------------------------*/
static void static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep) yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
{ {
YYFPRINTF (yyo, "%s %s (", YYFPRINTF (yyo, "%s %s (",
skipping to change at line 946 skipping to change at line 1025
yy_symbol_value_print (yyo, yytype, yyvaluep); yy_symbol_value_print (yyo, yytype, yyvaluep);
YYFPRINTF (yyo, ")"); YYFPRINTF (yyo, ")");
} }
/*------------------------------------------------------------------. /*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its | | yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). | | TOP (included). |
`------------------------------------------------------------------*/ `------------------------------------------------------------------*/
static void static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{ {
YYFPRINTF (stderr, "Stack now"); YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++) for (; yybottom <= yytop; yybottom++)
{ {
int yybot = *yybottom; int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot); YYFPRINTF (stderr, " %d", yybot);
} }
YYFPRINTF (stderr, "\n"); YYFPRINTF (stderr, "\n");
} }
skipping to change at line 968 skipping to change at line 1047
do { \ do { \
if (yydebug) \ if (yydebug) \
yy_stack_print ((Bottom), (Top)); \ yy_stack_print ((Bottom), (Top)); \
} while (0) } while (0)
/*------------------------------------------------. /*------------------------------------------------.
| Report that the YYRULE is going to be reduced. | | Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/ `------------------------------------------------*/
static void static void
yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
{ {
unsigned long yylno = yyrline[yyrule]; int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule]; int yynrhs = yyr2[yyrule];
int yyi; int yyi;
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
yyrule - 1, yylno); yyrule - 1, yylno);
/* The symbols being reduced. */ /* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++) for (yyi = 0; yyi < yynrhs; yyi++)
{ {
YYFPRINTF (stderr, " $%d = ", yyi + 1); YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yy_symbol_print (stderr,
yystos[yyssp[yyi + 1 - yynrhs]], yystos[+yyssp[yyi + 1 - yynrhs]],
&yyvsp[(yyi + 1) - (yynrhs)] &yyvsp[(yyi + 1) - (yynrhs)]
); );
YYFPRINTF (stderr, "\n"); YYFPRINTF (stderr, "\n");
} }
} }
# define YY_REDUCE_PRINT(Rule) \ # define YY_REDUCE_PRINT(Rule) \
do { \ do { \
if (yydebug) \ if (yydebug) \
yy_reduce_print (yyssp, yyvsp, Rule); \ yy_reduce_print (yyssp, yyvsp, Rule); \
skipping to change at line 1023 skipping to change at line 1102
evaluated with infinite-precision integer arithmetic. */ evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH #ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000 # define YYMAXDEPTH 10000
#endif #endif
#if YYERROR_VERBOSE #if YYERROR_VERBOSE
# ifndef yystrlen # ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H # if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
# else # else
/* Return the length of YYSTR. */ /* Return the length of YYSTR. */
static YYSIZE_T static YYPTRDIFF_T
yystrlen (const char *yystr) yystrlen (const char *yystr)
{ {
YYSIZE_T yylen; YYPTRDIFF_T yylen;
for (yylen = 0; yystr[yylen]; yylen++) for (yylen = 0; yystr[yylen]; yylen++)
continue; continue;
return yylen; return yylen;
} }
# endif # endif
# endif # endif
# ifndef yystpcpy # ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy # define yystpcpy stpcpy
skipping to change at line 1065 skipping to change at line 1144
# endif # endif
# ifndef yytnamerr # ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes, so that it's suitable for yyerror. The quotes and backslashes, so that it's suitable for yyerror. The
heuristic is that double-quoting is unnecessary unless the string heuristic is that double-quoting is unnecessary unless the string
contains an apostrophe, a comma, or backslash (other than contains an apostrophe, a comma, or backslash (other than
backslash-backslash). YYSTR is taken from yytname. If YYRES is backslash-backslash). YYSTR is taken from yytname. If YYRES is
null, do not copy; instead, return the length of what the result null, do not copy; instead, return the length of what the result
would have been. */ would have been. */
static YYSIZE_T static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr) yytnamerr (char *yyres, const char *yystr)
{ {
if (*yystr == '"') if (*yystr == '"')
{ {
YYSIZE_T yyn = 0; YYPTRDIFF_T yyn = 0;
char const *yyp = yystr; char const *yyp = yystr;
for (;;) for (;;)
switch (*++yyp) switch (*++yyp)
{ {
case '\'': case '\'':
case ',': case ',':
goto do_not_strip_quotes; goto do_not_strip_quotes;
case '\\': case '\\':
skipping to change at line 1101 skipping to change at line 1180
break; break;
case '"': case '"':
if (yyres) if (yyres)
yyres[yyn] = '\0'; yyres[yyn] = '\0';
return yyn; return yyn;
} }
do_not_strip_quotes: ; do_not_strip_quotes: ;
} }
if (! yyres) if (yyres)
return yystpcpy (yyres, yystr) - yyres;
else
return yystrlen (yystr); return yystrlen (yystr);
return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
} }
# endif # endif
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is about the unexpected token YYTOKEN for the state stack whose top is
YYSSP. YYSSP.
Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
not large enough to hold the message. In that case, also set not large enough to hold the message. In that case, also set
*YYMSG_ALLOC to the required number of bytes. Return 2 if the *YYMSG_ALLOC to the required number of bytes. Return 2 if the
required number of bytes is too large to store. */ required number of bytes is too large to store. */
static int static int
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
yytype_int16 *yyssp, int yytoken) yy_state_t *yyssp, int yytoken)
{ {
YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */ /* Internationalized format string. */
const char *yyformat = YY_NULLPTR; const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat. */ /* Arguments of yyformat: reported tokens (one for the "unexpected",
one per "expected"). */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per /* Actual size of YYARG. */
"expected"). */
int yycount = 0; int yycount = 0;
/* Cumulated lengths of YYARG. */
YYPTRDIFF_T yysize = 0;
/* There are many possibilities here to consider: /* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then - If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected is an error action. In that case, don't check for expected
tokens because there are none. tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if - The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus, this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that that there is no unexpected or expected token to report. In that
skipping to change at line 1156 skipping to change at line 1235
correct lookahead information, and it depends on the parser not correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected (from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be one exception: it will still contain any token that will not be
accepted due to an error action in a later state. accepted due to an error action in a later state.
*/ */
if (yytoken != YYEMPTY) if (yytoken != YYEMPTY)
{ {
int yyn = yypact[*yyssp]; int yyn = yypact[+*yyssp];
YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
yysize = yysize0;
yyarg[yycount++] = yytname[yytoken]; yyarg[yycount++] = yytname[yytoken];
if (!yypact_value_is_default (yyn)) if (!yypact_value_is_default (yyn))
{ {
/* Start YYX at -YYN if negative to avoid negative indexes in /* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */ this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0; int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */ /* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1; int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
skipping to change at line 1181 skipping to change at line 1262
&& !yytable_value_is_error (yytable[yyx + yyn])) && !yytable_value_is_error (yytable[yyx + yyn]))
{ {
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{ {
yycount = 1; yycount = 1;
yysize = yysize0; yysize = yysize0;
break; break;
} }
yyarg[yycount++] = yytname[yyx]; yyarg[yycount++] = yytname[yyx];
{ {
YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx YYPTRDIFF_T yysize1
]); = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
yysize = yysize1; yysize = yysize1;
else else
return 2; return 2;
} }
} }
} }
} }
switch (yycount) switch (yycount)
skipping to change at line 1208 skipping to change at line 1290
YYCASE_(0, YY_("syntax error")); YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %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_(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")); YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or % s"));
# undef YYCASE_ # undef YYCASE_
} }
{ {
YYSIZE_T yysize1 = yysize + yystrlen (yyformat); /* Don't count the "%s"s in the final size, but reserve room for
the terminator. */
YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
yysize = yysize1; yysize = yysize1;
else else
return 2; return 2;
} }
if (*yymsg_alloc < yysize) if (*yymsg_alloc < yysize)
{ {
*yymsg_alloc = 2 * yysize; *yymsg_alloc = 2 * yysize;
if (! (yysize <= *yymsg_alloc if (! (yysize <= *yymsg_alloc
skipping to change at line 1238 skipping to change at line 1322
char *yyp = *yymsg; char *yyp = *yymsg;
int yyi = 0; int yyi = 0;
while ((*yyp = *yyformat) != '\0') while ((*yyp = *yyformat) != '\0')
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{ {
yyp += yytnamerr (yyp, yyarg[yyi++]); yyp += yytnamerr (yyp, yyarg[yyi++]);
yyformat += 2; yyformat += 2;
} }
else else
{ {
yyp++; ++yyp;
yyformat++; ++yyformat;
} }
} }
return 0; return 0;
} }
#endif /* YYERROR_VERBOSE */ #endif /* YYERROR_VERBOSE */
/*-----------------------------------------------. /*-----------------------------------------------.
| Release the memory associated to this symbol. | | Release the memory associated to this symbol. |
`-----------------------------------------------*/ `-----------------------------------------------*/
skipping to change at line 1278 skipping to change at line 1362
/* Number of syntax errors so far. */ /* Number of syntax errors so far. */
int yynerrs; int yynerrs;
/*----------. /*----------.
| yyparse. | | yyparse. |
`----------*/ `----------*/
int int
yyparse (void) yyparse (void)
{ {
int yystate; yy_state_fast_t yystate;
/* Number of tokens to shift before error messages enabled. */ /* Number of tokens to shift before error messages enabled. */
int yyerrstatus; int yyerrstatus;
/* The stacks and their tools: /* The stacks and their tools:
'yyss': related to states. 'yyss': related to states.
'yyvs': related to semantic values. 'yyvs': related to semantic values.
Refer to the stacks through separate pointers, to allow yyoverflow Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */ to reallocate them elsewhere. */
/* The state stack. */ /* The state stack. */
yytype_int16 yyssa[YYINITDEPTH]; yy_state_t yyssa[YYINITDEPTH];
yytype_int16 *yyss; yy_state_t *yyss;
yytype_int16 *yyssp; yy_state_t *yyssp;
/* The semantic value stack. */ /* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs; YYSTYPE *yyvs;
YYSTYPE *yyvsp; YYSTYPE *yyvsp;
YYSIZE_T yystacksize; YYPTRDIFF_T yystacksize;
int yyn; int yyn;
int yyresult; int yyresult;
/* Lookahead token as an internal (translated) token number. */ /* Lookahead token as an internal (translated) token number. */
int yytoken = 0; int yytoken = 0;
/* The variables used to return semantic value and location from the /* The variables used to return semantic value and location from the
action routines. */ action routines. */
YYSTYPE yyval; YYSTYPE yyval;
#if YYERROR_VERBOSE #if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */ /* Buffer for error messages, and its allocated size. */
char yymsgbuf[128]; char yymsgbuf[128];
char *yymsg = yymsgbuf; char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf; YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif #endif
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
/* The number of symbols on the RHS of the reduced rule. /* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */ Keep to zero when no symbol should be popped. */
int yylen = 0; int yylen = 0;
yyssp = yyss = yyssa; yyssp = yyss = yyssa;
yyvsp = yyvs = yyvsa; yyvsp = yyvs = yyvsa;
skipping to change at line 1343 skipping to change at line 1427
/*------------------------------------------------------------. /*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate. | | yynewstate -- push a new state, which is found in yystate. |
`------------------------------------------------------------*/ `------------------------------------------------------------*/
yynewstate: yynewstate:
/* In all cases, when you get here, the value and location stacks /* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */ have just been pushed. So pushing a state here evens the stacks. */
yyssp++; yyssp++;
/*--------------------------------------------------------------------. /*--------------------------------------------------------------------.
| yynewstate -- set current state (the top of the stack) to yystate. | | yysetstate -- set current state (the top of the stack) to yystate. |
`--------------------------------------------------------------------*/ `--------------------------------------------------------------------*/
yysetstate: yysetstate:
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); YYDPRINTF ((stderr, "Entering state %d\n", yystate));
YY_ASSERT (0 <= yystate && yystate < YYNSTATES); YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
*yyssp = (yytype_int16) yystate; YY_IGNORE_USELESS_CAST_BEGIN
*yyssp = YY_CAST (yy_state_t, yystate);
YY_IGNORE_USELESS_CAST_END
if (yyss + yystacksize - 1 <= yyssp) if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE #if !defined yyoverflow && !defined YYSTACK_RELOCATE
goto yyexhaustedlab; goto yyexhaustedlab;
#else #else
{ {
/* Get the current used size of the three stacks, in elements. */ /* Get the current used size of the three stacks, in elements. */
YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); YYPTRDIFF_T yysize = yyssp - yyss + 1;
# if defined yyoverflow # if defined yyoverflow
{ {
/* Give user a chance to reallocate the stack. Use copies of /* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into these so that the &'s don't force the real ones into
memory. */ memory. */
yy_state_t *yyss1 = yyss;
YYSTYPE *yyvs1 = yyvs; YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
/* Each stack pointer address is followed by the size of the /* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */ be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"), yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp), &yyss1, yysize * YYSIZEOF (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp), &yyvs1, yysize * YYSIZEOF (*yyvsp),
&yystacksize); &yystacksize);
yyss = yyss1; yyss = yyss1;
yyvs = yyvs1; yyvs = yyvs1;
} }
# else /* defined YYSTACK_RELOCATE */ # else /* defined YYSTACK_RELOCATE */
/* Extend the stack our own way. */ /* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize) if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab; goto yyexhaustedlab;
yystacksize *= 2; yystacksize *= 2;
if (YYMAXDEPTH < yystacksize) if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH; yystacksize = YYMAXDEPTH;
{ {
yytype_int16 *yyss1 = yyss; yy_state_t *yyss1 = yyss;
union yyalloc *yyptr = union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); YY_CAST (union yyalloc *,
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)
)));
if (! yyptr) if (! yyptr)
goto yyexhaustedlab; goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs); YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE # undef YYSTACK_RELOCATE
if (yyss1 != yyssa) if (yyss1 != yyssa)
YYSTACK_FREE (yyss1); YYSTACK_FREE (yyss1);
} }
# endif # endif
yyssp = yyss + yysize - 1; yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1; yyvsp = yyvs + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n", YY_IGNORE_USELESS_CAST_BEGIN
(unsigned long) yystacksize)); YYDPRINTF ((stderr, "Stack size increased to %ld\n",
YY_CAST (long, yystacksize)));
YY_IGNORE_USELESS_CAST_END
if (yyss + yystacksize - 1 <= yyssp) if (yyss + yystacksize - 1 <= yyssp)
YYABORT; YYABORT;
} }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
if (yystate == YYFINAL) if (yystate == YYFINAL)
YYACCEPT; YYACCEPT;
goto yybackup; goto yybackup;
skipping to change at line 1468 skipping to change at line 1557
goto yyreduce; goto yyreduce;
} }
/* Count tokens shifted since error; after three, turn off error /* Count tokens shifted since error; after three, turn off error
status. */ status. */
if (yyerrstatus) if (yyerrstatus)
yyerrstatus--; yyerrstatus--;
/* Shift the lookahead token. */ /* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
/* Discard the shifted token. */
yychar = YYEMPTY;
yystate = yyn; yystate = yyn;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval; *++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Discard the shifted token. */
yychar = YYEMPTY;
goto yynewstate; goto yynewstate;
/*-----------------------------------------------------------. /*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. | | yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/ `-----------------------------------------------------------*/
yydefault: yydefault:
yyn = yydefact[yystate]; yyn = yydefact[yystate];
if (yyn == 0) if (yyn == 0)
goto yyerrlab; goto yyerrlab;
goto yyreduce; goto yyreduce;
skipping to change at line 1509 skipping to change at line 1597
users should not rely upon it. Assigning to YYVAL users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */ GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen]; yyval = yyvsp[1-yylen];
YY_REDUCE_PRINT (yyn); YY_REDUCE_PRINT (yyn);
switch (yyn) switch (yyn)
{ {
case 3: case 3:
#line 111 "command.y" #line 111 "command.y"
{ {
cmd_idx = -1; cmd_idx = -1;
want_nodeval = false; want_nodeval = false;
if (lexptr_begin != NULL) { if (lexptr_begin != NULL) {
if (input_from_tty && lexptr_begin[0] != '\0') if (input_from_tty && lexptr_begin[0] != '\0')
add_history(lexptr_begin); add_history(lexptr_begin);
efree(lexptr_begin); efree(lexptr_begin);
lexptr_begin = NULL; lexptr_begin = NULL;
} }
if (arg_list != NULL) { if (arg_list != NULL) {
free_cmdarg(arg_list); free_cmdarg(arg_list);
arg_list = NULL; arg_list = NULL;
} }
} }
#line 1553 "command.c" #line 1642 "command.c"
break; break;
case 5: case 5:
#line 130 "command.y" #line 130 "command.y"
{ {
if (dbg_errcount == 0 && cmd_idx >= 0) { if (dbg_errcount == 0 && cmd_idx >= 0) {
Func_cmd cmdfunc; Func_cmd cmdfunc;
bool terminate = false; bool terminate = false;
CMDARG *args; CMDARG *args;
int ctype = 0; int ctype = 0;
ctype = cmdtab[cmd_idx].type; ctype = cmdtab[cmd_idx].type;
/* a blank line repeats previous command /* a blank line repeats previous command
* (list, next, nexti, step, stepi and continue without a rguments). * (list, next, nexti, step, stepi and continue without a rguments).
skipping to change at line 1577 skipping to change at line 1665
args = arg_list; args = arg_list;
arg_list = NULL; arg_list = NULL;
terminate = (*cmdfunc)(args, ctype); terminate = (*cmdfunc)(args, ctype);
if (! in_commands || ctype == D_commands) if (! in_commands || ctype == D_commands)
free_cmdarg(args); free_cmdarg(args);
if (terminate) if (terminate)
YYACCEPT; YYACCEPT;
} }
} }
#line 1607 "command.c" #line 1696 "command.c"
break; break;
case 6: case 6:
#line 180 "command.y" #line 180 "command.y"
{ {
yyerrok; yyerrok;
} }
#line 1615 "command.c" #line 1704 "command.c"
break; break;
case 22: case 22:
#line 214 "command.y" #line 214 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1621 "command.c" #line 1710 "command.c"
break; break;
case 23: case 23:
#line 219 "command.y" #line 219 "command.y"
{ {
if (dbg_errcount == 0) { if (dbg_errcount == 0) {
/* don't free arg_list; passed on to statement_list /* don't free arg_list; passed on to statement_list
* non-terminal (empty rule action). See below. * non-terminal (empty rule action). See below.
*/ */
if (input_from_tty) { if (input_from_tty) {
dbg_prompt = eval_prompt; dbg_prompt = eval_prompt;
fprintf(out_fp, fprintf(out_fp,
_("Type (g)awk statement(s). End with the command \"end\"\n")); _("Type (g)awk statement(s). End with the command `end'\n"));
rl_inhibit_completion = 1; rl_inhibit_completion = 1;
} }
cmd_idx = -1; cmd_idx = -1;
in_eval = true; in_eval = true;
} }
} }
#line 1641 "command.c" #line 1730 "command.c"
break; break;
case 24: case 24:
#line 238 "command.y" #line 238 "command.y"
{ {
yyval = append_statement(arg_list, (char *) start_EVAL); yyval = append_statement(arg_list, (char *) start_EVAL);
if (read_a_line == read_commands_string) /* unserializing 'eval' in 'commands' */ if (read_a_line == read_commands_string) /* unserializing 'eval' in 'commands' */
yyval->a_string[0] = '\0'; yyval->a_string[0] = '\0';
free_cmdarg(arg_list); free_cmdarg(arg_list);
arg_list = NULL; arg_list = NULL;
} }
#line 1653 "command.c" #line 1742 "command.c"
break; break;
case 25: case 25:
#line 245 "command.y" #line 245 "command.y"
{ yyval = append_statement(yyvsp[-1], lexptr_begin); } { yyval = append_statement(yyvsp[-1], lexpt
#line 1659 "command.c" r_begin); }
#line 1748 "command.c"
break; break;
case 26: case 26:
#line 246 "command.y" #line 246 "command.y"
{ {
yyval = yyvsp[-1]; yyval = yyvsp[-1];
} }
#line 1667 "command.c" #line 1756 "command.c"
break; break;
case 27: case 27:
#line 253 "command.y" #line 253 "command.y"
{ {
arg_list = append_statement(yyvsp[-1], (char *) end_EVAL); arg_list = append_statement(yyvsp[-1], (char *) end_EVAL);
if (read_a_line == read_commands_string) { /* unserializing 'eval' in 'commands' */ if (read_a_line == read_commands_string) { /* unserializing 'eval' in 'commands' */
char *str = arg_list->a_string; char *str = arg_list->a_string;
size_t len = strlen(str); size_t len = strlen(str);
assert(len > 2 && str[len - 2] == '}'); assert(len > 2 && str[len - 2] == '}');
str[len - 2] = '\0'; str[len - 2] = '\0';
} }
if (input_from_tty) { if (input_from_tty) {
dbg_prompt = in_commands ? commands_prompt : dgawk_prompt ; dbg_prompt = in_commands ? commands_prompt : dgawk_prompt ;
rl_inhibit_completion = 0; rl_inhibit_completion = 0;
} }
cmd_idx = find_command("eval", 4); cmd_idx = find_command("eval", 4);
in_eval = false; in_eval = false;
} }
#line 1687 "command.c" #line 1776 "command.c"
break; break;
case 28: case 28:
#line 269 "command.y" #line 269 "command.y"
{ {
NODE *n; NODE *n;
CMDARG *arg; CMDARG *arg;
n = yyvsp[0]->a_node; n = yyvsp[0]->a_node;
arg = append_statement(NULL, (char *) start_EVAL); arg = append_statement(NULL, (char *) start_EVAL);
(void) append_statement(arg, n->stptr); (void) append_statement(arg, n->stptr);
(void) append_statement(arg, (char *) end_EVAL); (void) append_statement(arg, (char *) end_EVAL);
free_cmdarg(arg_list); free_cmdarg(arg_list);
arg_list = arg; arg_list = arg;
} }
#line 1702 "command.c" #line 1791 "command.c"
break; break;
case 34: case 34:
#line 288 "command.y" #line 288 "command.y"
{ {
if (cmdtab[cmd_idx].class == D_FRAME if (cmdtab[cmd_idx].class == D_FRAME
&& yyvsp[0] != NULL && yyvsp[0]->a_int < 0) && yyvsp[0] != NULL && yyvsp[0]->a_int < 0)
yyerror(_("invalid frame number: %d"), yyvsp[0]->a_int); yyerror(_("invalid frame number: %d"), yyvsp[0]->a_int);
} }
#line 1712 "command.c" #line 1801 "command.c"
break; break;
case 35: case 35:
#line 294 "command.y" #line 294 "command.y"
{ {
int idx = find_argument(yyvsp[0]); int idx = find_argument(yyvsp[0]);
if (idx < 0) if (idx < 0)
yyerror(_("info: invalid option - \"%s\""), yyvsp[0]->a_s tring); yyerror(_("info: invalid option - `%s'"), yyvsp[0]->a_str ing);
else { else {
efree(yyvsp[0]->a_string); efree(yyvsp[0]->a_string);
yyvsp[0]->a_string = NULL; yyvsp[0]->a_string = NULL;
yyvsp[0]->type = D_argument; yyvsp[0]->type = D_argument;
yyvsp[0]->a_argument = argtab[idx].value; yyvsp[0]->a_argument = argtab[idx].value;
} }
} }
#line 1728 "command.c" #line 1817 "command.c"
break; break;
case 38: case 38:
#line 307 "command.y" #line 307 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1734 "command.c" #line 1823 "command.c"
break; break;
case 40: case 40:
#line 308 "command.y" #line 308 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1740 "command.c" #line 1829 "command.c"
break; break;
case 46: case 46:
#line 313 "command.y" #line 313 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1746 "command.c" #line 1835 "command.c"
break; break;
case 49: case 49:
#line 315 "command.y" #line 315 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1752 "command.c" #line 1841 "command.c"
break; break;
case 51: case 51:
#line 316 "command.y" #line 316 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1758 "command.c" #line 1847 "command.c"
break; break;
case 53: case 53:
#line 317 "command.y" #line 317 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1764 "command.c" #line 1853 "command.c"
break; break;
case 57: case 57:
#line 321 "command.y" #line 321 "command.y"
{ {
if (in_cmd_src(yyvsp[0]->a_string)) if (in_cmd_src(yyvsp[0]->a_string))
yyerror(_("source \"%s\": already sourced."), yyvsp[0]->a _string); yyerror(_("source: `%s': already sourced."), yyvsp[0]->a_ string);
} }
#line 1773 "command.c" #line 1862 "command.c"
break; break;
case 58: case 58:
#line 326 "command.y" #line 326 "command.y"
{ {
if (! input_from_tty) if (! input_from_tty)
yyerror(_("save \"%s\": command not permitted."), yyvsp[0 ]->a_string); yyerror(_("save: `%s': command not permitted."), yyvsp[0] ->a_string);
} }
#line 1782 "command.c" #line 1871 "command.c"
break; break;
case 59: case 59:
#line 331 "command.y" #line 331 "command.y"
{ {
int type = 0; int type = 0;
int num; int num;
if (yyvsp[0] != NULL) if (yyvsp[0] != NULL)
num = yyvsp[0]->a_int; num = yyvsp[0]->a_int;
if (dbg_errcount != 0) if (dbg_errcount != 0)
; ;
else if (in_commands) else if (in_commands)
yyerror(_("Can't use command `commands' for breakpoint/wa tchpoint commands")); yyerror(_("cannot use command `commands' for breakpoint/w atchpoint commands"));
else if (yyvsp[0] == NULL && ! (type = has_break_or_watch_point( &num, true))) else if (yyvsp[0] == NULL && ! (type = has_break_or_watch_point( &num, true)))
yyerror(_("no breakpoint/watchpoint has been set yet")); yyerror(_("no breakpoint/watchpoint has been set yet"));
else if (yyvsp[0] != NULL && ! (type = has_break_or_watch_point(& num, false))) else if (yyvsp[0] != NULL && ! (type = has_break_or_watch_point(& num, false)))
yyerror(_("invalid breakpoint/watchpoint number")); yyerror(_("invalid breakpoint/watchpoint number"));
if (type) { if (type) {
in_commands = true; in_commands = true;
if (input_from_tty) { if (input_from_tty) {
dbg_prompt = commands_prompt; dbg_prompt = commands_prompt;
fprintf(out_fp, _("Type commands for when %s %d i s hit, one per line.\n"), fprintf(out_fp, _("Type commands for when %s %d i s hit, one per line.\n"),
(type == D_break) ? "breakpoint" : "watchpoint", num); (type == D_break) ? "breakpoint" : "watchpoint", num);
fprintf(out_fp, _("End with the command \"end\"\n ")); fprintf(out_fp, _("End with the command `end'\n") );
} }
} }
} }
#line 1812 "command.c" #line 1901 "command.c"
break; break;
case 60: case 60:
#line 357 "command.y" #line 357 "command.y"
{ {
if (! in_commands) if (! in_commands)
yyerror(_("`end' valid only in command `commands' or `eva l'")); yyerror(_("`end' valid only in command `commands' or `eva l'"));
else { else {
if (input_from_tty) if (input_from_tty)
dbg_prompt = dgawk_prompt; dbg_prompt = dgawk_prompt;
in_commands = false; in_commands = false;
} }
} }
#line 1826 "command.c" #line 1915 "command.c"
break; break;
case 61: case 61:
#line 367 "command.y" #line 367 "command.y"
{ {
if (! in_commands) if (! in_commands)
yyerror(_("`silent' valid only in command `commands'")); yyerror(_("`silent' valid only in command `commands'"));
} }
#line 1835 "command.c" #line 1924 "command.c"
break; break;
case 62: case 62:
#line 372 "command.y" #line 372 "command.y"
{ {
int idx = find_argument(yyvsp[0]); int idx = find_argument(yyvsp[0]);
if (idx < 0) if (idx < 0)
yyerror(_("trace: invalid option - \"%s\""), yyvsp[0]->a_ string); yyerror(_("trace: invalid option - `%s'"), yyvsp[0]->a_st ring);
else { else {
efree(yyvsp[0]->a_string); efree(yyvsp[0]->a_string);
yyvsp[0]->a_string = NULL; yyvsp[0]->a_string = NULL;
yyvsp[0]->type = D_argument; yyvsp[0]->type = D_argument;
yyvsp[0]->a_argument = argtab[idx].value; yyvsp[0]->a_argument = argtab[idx].value;
} }
} }
#line 1851 "command.c" #line 1940 "command.c"
break; break;
case 63: case 63:
#line 383 "command.y" #line 383 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1857 "command.c" #line 1946 "command.c"
break; break;
case 64: case 64:
#line 384 "command.y" #line 384 "command.y"
{ {
int type; int type;
int num = yyvsp[-2]->a_int; int num = yyvsp[-2]->a_int;
type = has_break_or_watch_point(&num, false); type = has_break_or_watch_point(&num, false);
if (! type) if (! type)
yyerror(_("condition: invalid breakpoint/watchpoint numbe r")); yyerror(_("condition: invalid breakpoint/watchpoint numbe r"));
} }
#line 1869 "command.c" #line 1958 "command.c"
break; break;
case 65: case 65:
#line 392 "command.y" #line 392 "command.y"
{ {
if (in_commands) { if (in_commands) {
/* Prepend command 'eval' to argument list */ /* Prepend command 'eval' to argument list */
CMDARG *arg; CMDARG *arg;
arg = mk_cmdarg(D_string); arg = mk_cmdarg(D_string);
arg->a_string = estrdup("eval", 4); arg->a_string = estrdup("eval", 4);
arg->next = arg_list; arg->next = arg_list;
arg_list = arg; arg_list = arg;
} }
} }
#line 1884 "command.c" #line 1973 "command.c"
break; break;
case 66: case 66:
#line 406 "command.y" #line 406 "command.y"
{ {
if (yyvsp[0] != NULL) { if (yyvsp[0] != NULL) {
NODE *n = yyvsp[0]->a_node; NODE *n = yyvsp[0]->a_node;
yyvsp[0]->type = D_string; yyvsp[0]->type = D_string;
yyvsp[0]->a_string = n->stptr; yyvsp[0]->a_string = n->stptr;
freenode(n); freenode(n);
} }
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 1898 "command.c" #line 1987 "command.c"
break; break;
case 68: case 68:
#line 420 "command.y" #line 420 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1904 "command.c" #line 1993 "command.c"
break; break;
case 69: case 69:
#line 425 "command.y" #line 425 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1910 "command.c" #line 1999 "command.c"
break; break;
case 74: case 74:
#line 434 "command.y" #line 434 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1916 "command.c" #line 2005 "command.c"
break; break;
case 75: case 75:
#line 439 "command.y" #line 439 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1922 "command.c" #line 2011 "command.c"
break; break;
case 77: case 77:
#line 442 "command.y" #line 442 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1928 "command.c" #line 2017 "command.c"
break; break;
case 78: case 78:
#line 447 "command.y" #line 447 "command.y"
{ {
NODE *n; NODE *n;
n = yyvsp[0]->a_node; n = yyvsp[0]->a_node;
if ((n->flags & STRING) == 0) if ((n->flags & STRING) == 0)
yyerror(_("argument not a string")); yyerror(_("argument not a string"));
} }
#line 1939 "command.c" #line 2028 "command.c"
break; break;
case 79: case 79:
#line 457 "command.y" #line 457 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1945 "command.c" #line 2034 "command.c"
break; break;
case 80: case 80:
#line 459 "command.y" #line 459 "command.y"
{ {
if (find_option(yyvsp[0]->a_string) < 0) if (find_option(yyvsp[0]->a_string) < 0)
yyerror(_("option: invalid parameter - \"%s\""), yyvsp[0] ->a_string); yyerror(_("option: invalid parameter - `%s'"), yyvsp[0]-> a_string);
} }
#line 1954 "command.c" #line 2043 "command.c"
break; break;
case 81: case 81:
#line 464 "command.y" #line 464 "command.y"
{ {
if (find_option(yyvsp[-2]->a_string) < 0) if (find_option(yyvsp[-2]->a_string) < 0)
yyerror(_("option: invalid parameter - \"%s\""), yyvsp[-2 ]->a_string); yyerror(_("option: invalid parameter - `%s'"), yyvsp[-2]- >a_string);
} }
#line 1963 "command.c" #line 2052 "command.c"
break; break;
case 82: case 82:
#line 472 "command.y" #line 472 "command.y"
{ {
NODE *n; NODE *n;
n = lookup(yyvsp[0]->a_string); n = lookup(yyvsp[0]->a_string);
if (n == NULL || n->type != Node_func) if (n == NULL || n->type != Node_func)
yyerror(_("no such function - \"%s\""), yyvsp[0]->a_strin g); yyerror(_("no such function - `%s'"), yyvsp[0]->a_string) ;
else { else {
yyvsp[0]->type = D_func; yyvsp[0]->type = D_func;
efree(yyvsp[0]->a_string); efree(yyvsp[0]->a_string);
yyvsp[0]->a_string = NULL; yyvsp[0]->a_string = NULL;
yyvsp[0]->a_node = n; yyvsp[0]->a_node = n;
} }
} }
#line 1980 "command.c" #line 2069 "command.c"
break; break;
case 83: case 83:
#line 488 "command.y" #line 488 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1986 "command.c" #line 2075 "command.c"
break; break;
case 88: case 88:
#line 497 "command.y" #line 497 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 1992 "command.c" #line 2081 "command.c"
break; break;
case 89: case 89:
#line 498 "command.y" #line 498 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 1998 "command.c" #line 2087 "command.c"
break; break;
case 92: case 92:
#line 500 "command.y" #line 500 "command.y"
{ want_nodeval = true; } { want_nodeval = true; }
#line 2004 "command.c" #line 2093 "command.c"
break; break;
case 95: case 95:
#line 506 "command.y" #line 506 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2010 "command.c" #line 2099 "command.c"
break; break;
case 97: case 97:
#line 512 "command.y" #line 512 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2016 "command.c" #line 2105 "command.c"
break; break;
case 99: case 99:
#line 518 "command.y" #line 518 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2022 "command.c" #line 2111 "command.c"
break; break;
case 104: case 104:
#line 530 "command.y" #line 530 "command.y"
{ {
int idx = find_argument(yyvsp[-1]); int idx = find_argument(yyvsp[-1]);
if (idx < 0) if (idx < 0)
yyerror(_("enable: invalid option - \"%s\""), yyvsp[-1]-> a_string); yyerror(_("enable: invalid option - `%s'"), yyvsp[-1]->a_ string);
else { else {
efree(yyvsp[-1]->a_string); efree(yyvsp[-1]->a_string);
yyvsp[-1]->a_string = NULL; yyvsp[-1]->a_string = NULL;
yyvsp[-1]->type = D_argument; yyvsp[-1]->type = D_argument;
yyvsp[-1]->a_argument = argtab[idx].value; yyvsp[-1]->a_argument = argtab[idx].value;
} }
} }
#line 2038 "command.c" #line 2127 "command.c"
break; break;
case 106: case 106:
#line 546 "command.y" #line 546 "command.y"
{ {
yyvsp[0]->type = D_array; /* dump all items */ yyvsp[0]->type = D_array; /* dump all items */
yyvsp[0]->a_count = 0; yyvsp[0]->a_count = 0;
} }
#line 2047 "command.c" #line 2136 "command.c"
break; break;
case 107: case 107:
#line 551 "command.y" #line 551 "command.y"
{ {
yyvsp[-1]->type = D_array; yyvsp[-1]->type = D_array;
yyvsp[-1]->a_count = num_dim; yyvsp[-1]->a_count = num_dim;
} }
#line 2056 "command.c" #line 2145 "command.c"
break; break;
case 117: case 117:
#line 577 "command.y" #line 577 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2062 "command.c" #line 2151 "command.c"
break; break;
case 118: case 118:
#line 579 "command.y" #line 579 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2068 "command.c" #line 2157 "command.c"
break; break;
case 119: case 119:
#line 581 "command.y" #line 581 "command.y"
{ {
CMDARG *a; CMDARG *a;
a = mk_cmdarg(D_int); a = mk_cmdarg(D_int);
a->a_int = -1; a->a_int = -1;
append_cmdarg(a); append_cmdarg(a);
} }
#line 2079 "command.c" #line 2168 "command.c"
break; break;
case 126: case 126:
#line 597 "command.y" #line 597 "command.y"
{ {
if (yyvsp[-2]->a_int > yyvsp[0]->a_int) if (yyvsp[-2]->a_int > yyvsp[0]->a_int)
yyerror(_("invalid range specification: %d - %d"), yyerror(_("invalid range specification: %d - %d"),
yyvsp[-2]->a_int, yyvsp[0]->a_int); yyvsp[-2]->a_int, yyvsp[0]->a_int);
else else
yyvsp[-2]->type = D_range; yyvsp[-2]->type = D_range;
yyval = yyvsp[-2]; yyval = yyvsp[-2];
} }
#line 2092 "command.c" #line 2181 "command.c"
break; break;
case 127: case 127:
#line 609 "command.y" #line 609 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2098 "command.c" #line 2187 "command.c"
break; break;
case 134: case 134:
#line 623 "command.y" #line 623 "command.y"
{ yyval = yyvsp[0]; } { yyval = yyvsp[0]; }
#line 2104 "command.c" #line 2193 "command.c"
break; break;
case 135: case 135:
#line 625 "command.y" #line 625 "command.y"
{ yyval = yyvsp[-2]; } { yyval = yyvsp[-2]; }
#line 2110 "command.c" #line 2199 "command.c"
break; break;
case 137: case 137:
#line 631 "command.y" #line 631 "command.y"
{ {
CMDARG *a; CMDARG *a;
NODE *subs; NODE *subs;
int count = 0; int count = 0;
for (a = yyvsp[-1]; a != NULL; a = a->next) for (a = yyvsp[-1]; a != NULL; a = a->next)
count++; count++;
subs = concat_args(yyvsp[-1], count); subs = concat_args(yyvsp[-1], count);
free_cmdarg(yyvsp[-1]->next); free_cmdarg(yyvsp[-1]->next);
yyvsp[-1]->next = NULL; yyvsp[-1]->next = NULL;
yyvsp[-1]->type = D_node; yyvsp[-1]->type = D_node;
yyvsp[-1]->a_node = subs; yyvsp[-1]->a_node = subs;
yyval = yyvsp[-1]; yyval = yyvsp[-1];
} }
#line 2129 "command.c" #line 2218 "command.c"
break; break;
case 139: case 139:
#line 650 "command.y" #line 650 "command.y"
{ yyval = yyvsp[0]; num_dim = 1; } { yyval = yyvsp[0]; num_dim = 1; }
#line 2135 "command.c" #line 2224 "command.c"
break; break;
case 140: case 140:
#line 652 "command.y" #line 652 "command.y"
{ yyval = yyvsp[-1]; num_dim++; } { yyval = yyvsp[-1]; num_dim++; }
#line 2141 "command.c" #line 2230 "command.c"
break; break;
case 142: case 142:
#line 658 "command.y" #line 658 "command.y"
{ {
NODE *n = yyvsp[0]->a_node; NODE *n = yyvsp[0]->a_node;
if ((n->flags & NUMBER) == 0) if ((n->flags & NUMBER) == 0)
yyerror(_("non-numeric value for field number")); yyerror(_("non-numeric value for field number"));
else else
yyvsp[0]->type = D_field; yyvsp[0]->type = D_field;
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 2154 "command.c" #line 2243 "command.c"
break; break;
case 143: case 143:
#line 667 "command.y" #line 667 "command.y"
{ {
/* a_string is array name, a_count is dimension count */ /* a_string is array name, a_count is dimension count */
yyvsp[-1]->type = D_subscript; yyvsp[-1]->type = D_subscript;
yyvsp[-1]->a_count = num_dim; yyvsp[-1]->a_count = num_dim;
yyval = yyvsp[-1]; yyval = yyvsp[-1];
} }
#line 2165 "command.c" #line 2254 "command.c"
break; break;
case 144: case 144:
#line 677 "command.y" #line 677 "command.y"
{ yyval = yyvsp[0]; } { yyval = yyvsp[0]; }
#line 2171 "command.c" #line 2260 "command.c"
break; break;
case 145: case 145:
#line 679 "command.y" #line 679 "command.y"
{ {
NODE *n = yyvsp[0]->a_node; NODE *n = yyvsp[0]->a_node;
if ((n->flags & NUMBER) == 0) if ((n->flags & NUMBER) == 0)
yyerror(_("non-numeric value found, numeric expected")); yyerror(_("non-numeric value found, numeric expected"));
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 2182 "command.c" #line 2271 "command.c"
break; break;
case 146: case 146:
#line 686 "command.y" #line 686 "command.y"
{ {
NODE *n = yyvsp[0]->a_node; NODE *n = yyvsp[0]->a_node;
if ((n->flags & NUMBER) == 0) if ((n->flags & NUMBER) == 0)
yyerror(_("non-numeric value found, numeric expected")); yyerror(_("non-numeric value found, numeric expected"));
else else
negate_num(n); negate_num(n);
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 2195 "command.c" #line 2284 "command.c"
break; break;
case 147: case 147:
#line 698 "command.y" #line 698 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2201 "command.c" #line 2290 "command.c"
break; break;
case 148: case 148:
#line 700 "command.y" #line 700 "command.y"
{ yyval = yyvsp[0]; } { yyval = yyvsp[0]; }
#line 2207 "command.c" #line 2296 "command.c"
break; break;
case 149: case 149:
#line 705 "command.y" #line 705 "command.y"
{ yyval = NULL; } { yyval = NULL; }
#line 2213 "command.c" #line 2302 "command.c"
break; break;
case 150: case 150:
#line 707 "command.y" #line 707 "command.y"
{ yyval = yyvsp[0]; } { yyval = yyvsp[0]; }
#line 2219 "command.c" #line 2308 "command.c"
break; break;
case 151: case 151:
#line 712 "command.y" #line 712 "command.y"
{ {
if (yyvsp[0]->a_int == 0) if (yyvsp[0]->a_int == 0)
yyerror(_("non-zero integer value")); yyerror(_("non-zero integer value"));
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 2229 "command.c" #line 2318 "command.c"
break; break;
case 152: case 152:
#line 718 "command.y" #line 718 "command.y"
{ {
if (yyvsp[0]->a_int == 0) if (yyvsp[0]->a_int == 0)
yyerror(_("non-zero integer value")); yyerror(_("non-zero integer value"));
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 2239 "command.c" #line 2328 "command.c"
break; break;
case 153: case 153:
#line 727 "command.y" #line 727 "command.y"
{ yyval = yyvsp[0]; } { yyval = yyvsp[0]; }
#line 2245 "command.c" #line 2334 "command.c"
break; break;
case 154: case 154:
#line 729 "command.y" #line 729 "command.y"
{ yyval = yyvsp[0]; } { yyval = yyvsp[0]; }
#line 2251 "command.c" #line 2340 "command.c"
break; break;
case 155: case 155:
#line 731 "command.y" #line 731 "command.y"
{ {
yyvsp[0]->a_int = - yyvsp[0]->a_int; yyvsp[0]->a_int = - yyvsp[0]->a_int;
yyval = yyvsp[0]; yyval = yyvsp[0];
} }
#line 2260 "command.c" #line 2349 "command.c"
break; break;
case 156: case 156:
#line 739 "command.y" #line 739 "command.y"
{ {
if (lexptr_begin != NULL) { if (lexptr_begin != NULL) {
if (input_from_tty && lexptr_begin[0] != '\0') if (input_from_tty && lexptr_begin[0] != '\0')
add_history(lexptr_begin); add_history(lexptr_begin);
efree(lexptr_begin); efree(lexptr_begin);
lexptr_begin = NULL; lexptr_begin = NULL;
} }
} }
#line 2273 "command.c" #line 2362 "command.c"
break; break;
#line 2277 "command.c" #line 2366 "command.c"
default: break; default: break;
} }
/* User semantic actions sometimes alter yychar, and that requires /* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation. We take the that yytoken be updated with the new translation. We take the
approach of translating immediately before every use of yytoken. approach of translating immediately before every use of yytoken.
One alternative is translating here after every semantic action, One alternative is translating here after every semantic action,
but that translation would be missed if the semantic action invokes but that translation would be missed if the semantic action invokes
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
skipping to change at line 2309 skipping to change at line 2397
{ {
char const *yymsgp = YY_("syntax error"); char const *yymsgp = YY_("syntax error");
int yysyntax_error_status; int yysyntax_error_status;
yysyntax_error_status = YYSYNTAX_ERROR; yysyntax_error_status = YYSYNTAX_ERROR;
if (yysyntax_error_status == 0) if (yysyntax_error_status == 0)
yymsgp = yymsg; yymsgp = yymsg;
else if (yysyntax_error_status == 1) else if (yysyntax_error_status == 1)
{ {
if (yymsg != yymsgbuf) if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg); YYSTACK_FREE (yymsg);
yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_all oc)));
if (!yymsg) if (!yymsg)
{ {
yymsg = yymsgbuf; yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf; yymsg_alloc = sizeof yymsgbuf;
yysyntax_error_status = 2; yysyntax_error_status = 2;
} }
else else
{ {
yysyntax_error_status = YYSYNTAX_ERROR; yysyntax_error_status = YYSYNTAX_ERROR;
yymsgp = yymsg; yymsgp = yymsg;
skipping to change at line 2454 skipping to change at line 2542
yydestruct ("Cleanup: discarding lookahead", yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval); yytoken, &yylval);
} }
/* Do not reclaim the symbols of the rule whose action triggered /* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */ this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen); YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp); YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss) while (yyssp != yyss)
{ {
yydestruct ("Cleanup: popping", yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp); yystos[+*yyssp], yyvsp);
YYPOPSTACK (1); YYPOPSTACK (1);
} }
#ifndef yyoverflow #ifndef yyoverflow
if (yyss != yyssa) if (yyss != yyssa)
YYSTACK_FREE (yyss); YYSTACK_FREE (yyss);
#endif #endif
#if YYERROR_VERBOSE #if YYERROR_VERBOSE
if (yymsg != yymsgbuf) if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg); YYSTACK_FREE (yymsg);
#endif #endif
skipping to change at line 2774 skipping to change at line 2862
lexptr_begin = read_a_line(dbg_prompt); lexptr_begin = read_a_line(dbg_prompt);
if (lexptr_begin == NULL) { /* EOF or error */ if (lexptr_begin == NULL) { /* EOF or error */
if (get_eof_status() == EXIT_FATAL) if (get_eof_status() == EXIT_FATAL)
exit(EXIT_FATAL); exit(EXIT_FATAL);
if (get_eof_status() == EXIT_FAILURE) { if (get_eof_status() == EXIT_FAILURE) {
static int seen_eof = 0; static int seen_eof = 0;
/* force a quit, and let do_quit (in debug.c) exi t */ /* force a quit, and let do_quit (in debug.c) exi t */
if (! seen_eof) { if (! seen_eof) {
if (errno != 0) { if (errno != 0) {
fprintf(stderr, _("can't read com mand (%s)\n"), strerror(errno)); fprintf(stderr, _("cannot read co mmand: %s\n"), strerror(errno));
exit_val = EXIT_FAILURE; exit_val = EXIT_FAILURE;
} /* else } /* else
exit_val = EXIT_SUCCESS; */ exit_val = EXIT_SUCCESS; */
seen_eof = 1; seen_eof = 1;
return '\n'; /* end current command if any */ return '\n'; /* end current command if any */
} else if (seen_eof++ == 1) { } else if (seen_eof++ == 1) {
cmd_idx = find_command("quit", 4); cmd_idx = find_command("quit", 4);
return D_QUIT; /* 'quit' token */ return D_QUIT; /* 'quit' token */
} else } else
return '\n'; /* end command 'quit' */ return '\n'; /* end command 'quit' */
} }
if (errno != 0) if (errno != 0)
d_error(_("can't read command (%s)"), strerror(er rno)); d_error(_("cannot read command: %s"), strerror(er rno));
if (pop_cmd_src() == 0) if (pop_cmd_src() == 0)
goto again; goto again;
exit(EXIT_FATAL); /* shouldn't happen */ exit(EXIT_FATAL); /* shouldn't happen */
} }
if (! in_commands && ! in_eval /* history expansion off in 'comm ands' and 'eval' */ if (! in_commands && ! in_eval /* history expansion off in 'comm ands' and 'eval' */
&& input_from_tty && input_from_tty
) )
history_expand_line(&lexptr_begin); history_expand_line(&lexptr_begin);
skipping to change at line 2875 skipping to change at line 2963
* arg_list; command string for 'eval' prepended to the arg_list * arg_list; command string for 'eval' prepended to the arg_list
* in the grammer above (see eval_cmd non-termina l). * in the grammer above (see eval_cmd non-termina l).
*/ */
CMDARG *arg; CMDARG *arg;
arg = mk_cmdarg(D_string); arg = mk_cmdarg(D_string);
arg->a_string = estrdup(lexptr_begin, lexend - le xptr_begin); arg->a_string = estrdup(lexptr_begin, lexend - le xptr_begin);
append_cmdarg(arg); append_cmdarg(arg);
} }
return cmdtab[cmd_idx].class; return cmdtab[cmd_idx].class;
} else { } else {
yyerror(_("unknown command - \"%.*s\", try help"), toklen , tokstart); yyerror(_("unknown command - `%.*s', try help"), toklen, tokstart);
return '\n'; return '\n';
} }
} }
c = *lexptr; c = *lexptr;
if (cmdtab[cmd_idx].type == D_option) { if (cmdtab[cmd_idx].type == D_option) {
if (c == '=') if (c == '=')
return *lexptr++; return *lexptr++;
} else if (c == '-' || c == '+' || c == ':' || c == '|') } else if (c == '-' || c == '+' || c == ':' || c == '|')
 End of changes. 204 change blocks. 
263 lines changed or deleted 352 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)