-/* A Bison parser, made by GNU Bison 2.0. */
-
-/* Skeleton parser for Yacc-like parsing with Bison,
- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
-
- This program is free software; you can redistribute it and/or modify
+/* A Bison parser, made by GNU Bison 2.4.3. */
+
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+ 2009, 2010 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 2, or (at your option)
- any later version.
-
+ 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, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
-
-/* As a special exception, when this file is copied by Bison into a
- Bison output file, you may use that output file without restriction.
- This special exception was added by the Free Software Foundation
- in version 1.24 of Bison. */
-
-/* Written by Richard Stallman by simplifying the original so called
- ``semantic'' parser. */
+ along with this program. If not, see <http://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. */
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
/* Identify Bison output. */
#define YYBISON 1
+/* Bison version. */
+#define YYBISON_VERSION "2.4.3"
+
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 0
-/* Using locations. */
-#define YYLSP_NEEDED 0
-
+/* Push parsers. */
+#define YYPUSH 0
+/* Pull parsers. */
+#define YYPULL 1
-/* Tokens. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- /* Put the tokens into the symbol table, so that GDB and other debuggers
- know about them. */
- enum yytokentype {
- CLASS = 258,
- FROM = 259,
- CONST = 260,
- VOID = 261,
- STRUCT = 262,
- UNION = 263,
- ENUM = 264,
- THREEDOTS = 265,
- SIGNED = 266,
- UNSIGNED = 267,
- LONG = 268,
- SHORT = 269,
- INT = 270,
- FLOAT = 271,
- DOUBLE = 272,
- CHAR = 273,
- TOKEN = 274,
- NUMBER = 275,
- TYPETOKEN = 276,
- ARRAY_DIM = 277,
- SINGLE_CHAR = 278,
- CCODE = 279,
- HTCODE = 280,
- PHCODE = 281,
- HCODE = 282,
- ACODE = 283,
- ATCODE = 284,
- STRING = 285,
- PUBLIC = 286,
- PRIVATE = 287,
- PROTECTED = 288,
- CLASSWIDE = 289,
- PROPERTY = 290,
- ARGUMENT = 291,
- VIRTUAL = 292,
- SIGNAL = 293,
- OVERRIDE = 294,
- NICK = 295,
- BLURB = 296,
- MAXIMUM = 297,
- MINIMUM = 298,
- DEFAULT_VALUE = 299,
- ERROR = 300,
- FLAGS = 301,
- TYPE = 302,
- FLAGS_TYPE = 303,
- ENUM_TYPE = 304,
- PARAM_TYPE = 305,
- BOXED_TYPE = 306,
- OBJECT_TYPE = 307
- };
-#endif
-#define CLASS 258
-#define FROM 259
-#define CONST 260
-#define VOID 261
-#define STRUCT 262
-#define UNION 263
-#define ENUM 264
-#define THREEDOTS 265
-#define SIGNED 266
-#define UNSIGNED 267
-#define LONG 268
-#define SHORT 269
-#define INT 270
-#define FLOAT 271
-#define DOUBLE 272
-#define CHAR 273
-#define TOKEN 274
-#define NUMBER 275
-#define TYPETOKEN 276
-#define ARRAY_DIM 277
-#define SINGLE_CHAR 278
-#define CCODE 279
-#define HTCODE 280
-#define PHCODE 281
-#define HCODE 282
-#define ACODE 283
-#define ATCODE 284
-#define STRING 285
-#define PUBLIC 286
-#define PRIVATE 287
-#define PROTECTED 288
-#define CLASSWIDE 289
-#define PROPERTY 290
-#define ARGUMENT 291
-#define VIRTUAL 292
-#define SIGNAL 293
-#define OVERRIDE 294
-#define NICK 295
-#define BLURB 296
-#define MAXIMUM 297
-#define MINIMUM 298
-#define DEFAULT_VALUE 299
-#define ERROR 300
-#define FLAGS 301
-#define TYPE 302
-#define FLAGS_TYPE 303
-#define ENUM_TYPE 304
-#define PARAM_TYPE 305
-#define BOXED_TYPE 306
-#define OBJECT_TYPE 307
-
+/* Using locations. */
+#define YYLSP_NEEDED 0
/* Copy the first part of user declarations. */
+
+/* Line 189 of yacc.c */
#line 23 "parse.y"
static int initializer_line = 0;
static int glade_widget = FALSE;
+static char *funcattrs = NULL;
static char *onerror = NULL;
static char *defreturn = NULL;
char *out=NULL;
char *p;
- if(strcmp(yytext,"\n")==0) {
- out=g_strconcat("Error: ",str," before newline",NULL);
- } else if(yytext[0]=='\0') {
+ if (strcmp (yytext, "\n") == 0 ||
+ strcmp (yytext, "\r") == 0) {
+ out = g_strconcat ("Error: ", str, " before end of line", NULL);
+ } else if (yytext[0] == '\0') {
out=g_strconcat("Error: ", str, " at end of input", NULL);
} else {
char *tmp = g_strdup(yytext);
g_assert(scope != CLASS_SCOPE);
- if(method == INIT_METHOD || method == CLASS_INIT_METHOD) {
+ if(method == INIT_METHOD ||
+ method == CLASS_INIT_METHOD ||
+ method == CONSTRUCTOR_METHOD ||
+ method == DISPOSE_METHOD ||
+ method == FINALIZE_METHOD) {
type = (Type *)node_new (TYPE_NODE,
"name", "void",
NULL);
"flags:steal", flags,
"id:steal", id,
"args:steal", funcargs,
+ "funcattrs:steal", funcattrs,
"onerror:steal", onerror,
"defreturn:steal", defreturn,
"cbuf:steal", c_cbuf,
gtktypes = NULL;
funcargs = NULL;
+ funcattrs = NULL;
onerror = NULL;
defreturn = NULL;
static void
free_all_global_state(void)
{
+ g_free(funcattrs);
+ funcattrs = NULL;
g_free(onerror);
onerror = NULL;
g_free(defreturn);
}
static gboolean
-set_return_value(char *type, char *val)
+set_attr_value(char *type, char *val)
{
- if(strcmp(type, "onerror")==0) {
+ if(strcmp(type, "attr")==0) {
+ if(!funcattrs) {
+ funcattrs = val;
+ return TRUE;
+ } else
+ return FALSE;
+ } else if(strcmp(type, "onerror")==0) {
if(!onerror) {
onerror = val;
return TRUE;
{
Node *var;
Type * type;
- GList * flags = NULL;
type = (Type *)node_new (TYPE_NODE,
"name", "GladeXML",
+/* Line 189 of yacc.c */
+#line 733 "parse.c"
+
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 1
# define YYERROR_VERBOSE 0
#endif
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 668 "parse.y"
-typedef union YYSTYPE {
+/* Enabling the token table. */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+
+/* Tokens. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ /* Put the tokens into the symbol table, so that GDB and other debuggers
+ know about them. */
+ enum yytokentype {
+ CLASS = 258,
+ FROM = 259,
+ CONST = 260,
+ VOID = 261,
+ STRUCT = 262,
+ UNION = 263,
+ ENUM = 264,
+ THREEDOTS = 265,
+ SIGNED = 266,
+ UNSIGNED = 267,
+ LONG = 268,
+ SHORT = 269,
+ INT = 270,
+ FLOAT = 271,
+ DOUBLE = 272,
+ CHAR = 273,
+ TOKEN = 274,
+ NUMBER = 275,
+ TYPETOKEN = 276,
+ ARRAY_DIM = 277,
+ SINGLE_CHAR = 278,
+ CCODE = 279,
+ CTCODE = 280,
+ ADCODE = 281,
+ HTCODE = 282,
+ PHCODE = 283,
+ HCODE = 284,
+ ACODE = 285,
+ ATCODE = 286,
+ STRING = 287,
+ PUBLIC = 288,
+ PRIVATE = 289,
+ PROTECTED = 290,
+ CLASSWIDE = 291,
+ PROPERTY = 292,
+ ARGUMENT = 293,
+ VIRTUAL = 294,
+ SIGNAL = 295,
+ OVERRIDE = 296,
+ NICK = 297,
+ BLURB = 298,
+ MAXIMUM = 299,
+ MINIMUM = 300,
+ DEFAULT_VALUE = 301,
+ ERROR = 302,
+ FLAGS = 303,
+ TYPE = 304,
+ FLAGS_TYPE = 305,
+ ENUM_TYPE = 306,
+ PARAM_TYPE = 307,
+ BOXED_TYPE = 308,
+ OBJECT_TYPE = 309
+ };
+#endif
+/* Tokens. */
+#define CLASS 258
+#define FROM 259
+#define CONST 260
+#define VOID 261
+#define STRUCT 262
+#define UNION 263
+#define ENUM 264
+#define THREEDOTS 265
+#define SIGNED 266
+#define UNSIGNED 267
+#define LONG 268
+#define SHORT 269
+#define INT 270
+#define FLOAT 271
+#define DOUBLE 272
+#define CHAR 273
+#define TOKEN 274
+#define NUMBER 275
+#define TYPETOKEN 276
+#define ARRAY_DIM 277
+#define SINGLE_CHAR 278
+#define CCODE 279
+#define CTCODE 280
+#define ADCODE 281
+#define HTCODE 282
+#define PHCODE 283
+#define HCODE 284
+#define ACODE 285
+#define ATCODE 286
+#define STRING 287
+#define PUBLIC 288
+#define PRIVATE 289
+#define PROTECTED 290
+#define CLASSWIDE 291
+#define PROPERTY 292
+#define ARGUMENT 293
+#define VIRTUAL 294
+#define SIGNAL 295
+#define OVERRIDE 296
+#define NICK 297
+#define BLURB 298
+#define MAXIMUM 299
+#define MINIMUM 300
+#define DEFAULT_VALUE 301
+#define ERROR 302
+#define FLAGS 303
+#define TYPE 304
+#define FLAGS_TYPE 305
+#define ENUM_TYPE 306
+#define PARAM_TYPE 307
+#define BOXED_TYPE 308
+#define OBJECT_TYPE 309
+
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+{
+
+/* Line 214 of yacc.c */
+#line 683 "parse.y"
+
char *id;
GString *cbuf;
GList *list;
int line;
int sigtype;
+
+
+
+/* Line 214 of yacc.c */
+#line 887 "parse.c"
} YYSTYPE;
-/* Line 190 of yacc.c. */
-#line 833 "y.tab.c"
+# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
#endif
-
/* Copy the second part of user declarations. */
-/* Line 213 of yacc.c. */
-#line 845 "y.tab.c"
+/* Line 264 of yacc.c */
+#line 899 "parse.c"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned int
+# endif
+#endif
-#if ! defined (yyoverflow) || YYERROR_VERBOSE
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-# ifndef YYFREE
-# define YYFREE free
+#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 YYMALLOC
-# define YYMALLOC malloc
+# ifndef YY_
+# define YY_(msgid) msgid
# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions. */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int yyi)
+#else
+static int
+YYID (yyi)
+ int yyi;
+#endif
+{
+ return yyi;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# 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 _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
+# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
- /* Pacify GCC's `empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-# else
-# if defined (__STDC__) || defined (__cplusplus)
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (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 _STDLIB_H \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
# endif
-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-#if (! defined (yyoverflow) \
- && (! defined (__cplusplus) \
- || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
- short int yyss;
- YYSTYPE yyvs;
- };
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
+};
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
- ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
/* Copy COUNT objects from FROM to TO. The source and destination do
not overlap. */
# ifndef YYCOPY
-# if defined (__GNUC__) && 1 < __GNUC__
+# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
# define YYCOPY(To, From, Count) \
do \
{ \
- register YYSIZE_T yyi; \
+ YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
- while (0)
+ while (YYID (0))
# endif
# endif
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) \
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
- YYCOPY (&yyptr->Stack, Stack, yysize); \
- Stack = &yyptr->Stack; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
- while (0)
-
-#endif
+ while (YYID (0))
-#if defined (__STDC__) || defined (__cplusplus)
- typedef signed char yysigned_char;
-#else
- typedef short int yysigned_char;
#endif
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 23
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 25
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 629
+#define YYLAST 641
-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 66
-/* YYNNTS -- Number of nonterminals. */
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 68
+/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 53
-/* YYNRULES -- Number of rules. */
-#define YYNRULES 195
-/* YYNRULES -- Number of states. */
-#define YYNSTATES 414
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 198
+/* YYNRULES -- Number of states. */
+#define YYNSTATES 418
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
-#define YYMAXUTOK 307
+#define YYMAXUTOK 309
-#define YYTRANSLATE(YYX) \
+#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
-static const unsigned char yytranslate[] =
+static const yytype_uint8 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, 64, 2, 2, 2, 2, 2, 2,
- 55, 56, 61, 2, 59, 65, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 57,
- 63, 58, 62, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 66, 2, 2, 2, 2, 2, 2,
+ 57, 58, 63, 2, 61, 67, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 59,
+ 65, 60, 64, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 53, 60, 54, 2, 2, 2, 2,
+ 2, 2, 2, 55, 62, 56, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
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, 41, 42, 43, 44,
- 45, 46, 47, 48, 49, 50, 51, 52
+ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54
};
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
-static const unsigned short int yyprhs[] =
+static const yytype_uint16 yyprhs[] =
{
0, 0, 3, 7, 10, 13, 15, 17, 19, 21,
- 23, 25, 27, 30, 33, 36, 39, 41, 43, 45,
- 47, 52, 56, 62, 63, 68, 74, 80, 86, 93,
- 101, 108, 116, 119, 121, 123, 126, 130, 132, 134,
- 136, 138, 140, 142, 144, 146, 149, 153, 156, 160,
- 163, 166, 168, 170, 172, 173, 179, 186, 199, 209,
- 216, 220, 221, 233, 242, 248, 252, 253, 257, 259,
- 261, 266, 268, 270, 274, 278, 282, 286, 290, 294,
- 298, 302, 306, 310, 314, 318, 322, 326, 330, 334,
- 338, 340, 346, 348, 352, 353, 357, 359, 362, 364,
- 366, 368, 371, 374, 377, 381, 385, 388, 391, 394,
- 396, 399, 401, 404, 406, 408, 410, 412, 414, 416,
- 418, 420, 422, 424, 426, 428, 430, 433, 436, 440,
- 443, 445, 449, 453, 456, 458, 463, 467, 469, 472,
- 474, 485, 497, 507, 517, 526, 538, 547, 553, 556,
- 561, 562, 564, 567, 569, 571, 574, 577, 581, 586,
- 591, 593, 597, 599, 603, 605, 608, 612, 619, 627,
- 630, 632, 634, 637, 640, 644, 648, 652, 656, 664,
- 673, 677, 679, 683, 685, 693, 702, 706, 708, 716,
- 725, 729, 731, 733, 736, 738
+ 23, 25, 27, 29, 31, 34, 37, 40, 43, 45,
+ 47, 49, 51, 56, 60, 66, 67, 72, 78, 84,
+ 90, 97, 105, 112, 120, 123, 125, 127, 130, 134,
+ 136, 138, 140, 142, 144, 146, 148, 150, 153, 157,
+ 160, 164, 167, 170, 172, 174, 176, 177, 183, 190,
+ 203, 213, 220, 224, 225, 237, 246, 252, 256, 257,
+ 261, 263, 265, 270, 272, 274, 278, 282, 286, 290,
+ 294, 298, 302, 306, 310, 314, 318, 322, 326, 330,
+ 334, 338, 342, 344, 350, 352, 356, 357, 361, 363,
+ 366, 368, 370, 372, 375, 378, 381, 385, 389, 392,
+ 395, 398, 400, 403, 405, 408, 410, 412, 414, 416,
+ 418, 420, 422, 424, 426, 428, 430, 432, 434, 437,
+ 440, 444, 447, 449, 453, 457, 460, 462, 467, 471,
+ 473, 476, 478, 489, 501, 511, 521, 530, 542, 551,
+ 557, 560, 565, 572, 573, 575, 578, 580, 582, 585,
+ 588, 592, 597, 602, 604, 608, 610, 614, 616, 619,
+ 623, 630, 638, 641, 643, 645, 648, 651, 655, 659,
+ 663, 667, 675, 684, 688, 690, 694, 696, 704, 713,
+ 717, 719, 727, 736, 740, 742, 744, 747, 749
};
-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const yysigned_char yyrhs[] =
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */
+static const yytype_int8 yyrhs[] =
{
- 67, 0, -1, 69, 70, 69, -1, 70, 69, -1,
- 69, 70, -1, 70, -1, 24, -1, 27, -1, 25,
- -1, 26, -1, 28, -1, 29, -1, 69, 68, -1,
- 69, 111, -1, 69, 114, -1, 69, 116, -1, 68,
- -1, 111, -1, 114, -1, 116, -1, 71, 53, 73,
- 54, -1, 71, 53, 54, -1, 3, 21, 4, 21,
- 72, -1, -1, 55, 19, 56, 72, -1, 55, 19,
- 19, 56, 72, -1, 55, 19, 21, 56, 72, -1,
- 55, 19, 20, 56, 72, -1, 55, 19, 30, 30,
- 56, 72, -1, 55, 19, 30, 30, 30, 56, 72,
- -1, 55, 19, 19, 30, 56, 72, -1, 55, 19,
- 19, 30, 30, 56, 72, -1, 73, 74, -1, 74,
- -1, 102, -1, 19, 102, -1, 19, 21, 102, -1,
- 79, -1, 80, -1, 82, -1, 57, -1, 31, -1,
- 32, -1, 33, -1, 34, -1, 19, 19, -1, 19,
- 53, 24, -1, 58, 118, -1, 58, 53, 24, -1,
- 76, 77, -1, 77, 76, -1, 77, -1, 76, -1,
- 19, -1, -1, 75, 91, 19, 78, 57, -1, 75,
- 91, 19, 22, 78, 57, -1, 36, 89, 88, 19,
- 81, 19, 53, 24, 19, 53, 24, 57, -1, 36,
- 89, 88, 19, 81, 19, 53, 24, 57, -1, 36,
- 89, 88, 19, 81, 19, -1, 55, 19, 56, -1,
- -1, 35, 19, 19, 83, 19, 53, 24, 19, 53,
- 24, 57, -1, 35, 19, 19, 83, 19, 53, 24,
- 57, -1, 35, 19, 19, 83, 57, -1, 55, 84,
- 56, -1, -1, 84, 59, 87, -1, 87, -1, 30,
- -1, 19, 55, 30, 56, -1, 118, -1, 85, -1,
- 40, 58, 85, -1, 41, 58, 85, -1, 42, 58,
- 118, -1, 43, 58, 118, -1, 44, 58, 86, -1,
- 46, 58, 90, -1, 47, 58, 91, -1, 48, 58,
- 21, -1, 48, 58, 19, -1, 49, 58, 21, -1,
- 49, 58, 19, -1, 50, 58, 21, -1, 50, 58,
- 19, -1, 51, 58, 21, -1, 51, 58, 19, -1,
- 52, 58, 21, -1, 52, 58, 19, -1, 19, -1,
- 19, 55, 19, 91, 56, -1, 19, -1, 55, 90,
- 56, -1, -1, 19, 60, 90, -1, 19, -1, 92,
- 96, -1, 92, -1, 93, -1, 19, -1, 5, 19,
- -1, 19, 5, -1, 95, 19, -1, 5, 95, 19,
- -1, 95, 19, 5, -1, 94, 93, -1, 21, 93,
- -1, 5, 93, -1, 21, -1, 21, 5, -1, 94,
- -1, 94, 5, -1, 6, -1, 18, -1, 14, -1,
- 15, -1, 13, -1, 16, -1, 17, -1, 11, -1,
- 12, -1, 7, -1, 8, -1, 9, -1, 61, -1,
- 61, 5, -1, 61, 96, -1, 61, 5, 96, -1,
- 19, 99, -1, 99, -1, 75, 19, 99, -1, 19,
- 75, 99, -1, 75, 99, -1, 97, -1, 19, 55,
- 100, 56, -1, 100, 59, 19, -1, 19, -1, 53,
- 24, -1, 57, -1, 38, 89, 98, 91, 19, 55,
- 105, 56, 103, 101, -1, 75, 38, 89, 97, 91,
- 19, 55, 105, 56, 103, 101, -1, 37, 75, 91,
- 19, 55, 105, 56, 103, 101, -1, 75, 37, 91,
- 19, 55, 105, 56, 103, 101, -1, 37, 91, 19,
- 55, 105, 56, 103, 101, -1, 39, 55, 21, 56,
- 91, 19, 55, 105, 56, 103, 101, -1, 75, 91,
- 19, 55, 105, 56, 103, 101, -1, 19, 55, 19,
- 56, 101, -1, 19, 104, -1, 19, 104, 19, 104,
- -1, -1, 118, -1, 53, 24, -1, 6, -1, 19,
- -1, 19, 5, -1, 5, 19, -1, 19, 59, 106,
- -1, 19, 5, 59, 106, -1, 5, 19, 59, 106,
- -1, 106, -1, 107, 59, 10, -1, 107, -1, 107,
- 59, 108, -1, 108, -1, 91, 19, -1, 91, 19,
- 22, -1, 91, 19, 55, 19, 109, 56, -1, 91,
- 19, 22, 55, 19, 109, 56, -1, 109, 110, -1,
- 110, -1, 19, -1, 62, 118, -1, 63, 118, -1,
- 62, 58, 118, -1, 63, 58, 118, -1, 58, 58,
- 118, -1, 64, 58, 118, -1, 9, 19, 53, 112,
- 54, 21, 57, -1, 9, 19, 53, 112, 59, 54,
- 21, 57, -1, 112, 59, 113, -1, 113, -1, 19,
- 58, 118, -1, 19, -1, 46, 19, 53, 115, 54,
- 21, 57, -1, 46, 19, 53, 115, 59, 54, 21,
- 57, -1, 115, 59, 19, -1, 19, -1, 45, 19,
- 53, 117, 54, 21, 57, -1, 45, 19, 53, 117,
- 59, 54, 21, 57, -1, 117, 59, 19, -1, 19,
- -1, 20, -1, 65, 20, -1, 23, -1, 19, -1
+ 69, 0, -1, 71, 72, 71, -1, 72, 71, -1,
+ 71, 72, -1, 72, -1, 24, -1, 26, -1, 29,
+ -1, 27, -1, 28, -1, 30, -1, 31, -1, 25,
+ -1, 71, 70, -1, 71, 113, -1, 71, 116, -1,
+ 71, 118, -1, 70, -1, 113, -1, 116, -1, 118,
+ -1, 73, 55, 75, 56, -1, 73, 55, 56, -1,
+ 3, 21, 4, 21, 74, -1, -1, 57, 19, 58,
+ 74, -1, 57, 19, 19, 58, 74, -1, 57, 19,
+ 21, 58, 74, -1, 57, 19, 20, 58, 74, -1,
+ 57, 19, 32, 32, 58, 74, -1, 57, 19, 32,
+ 32, 32, 58, 74, -1, 57, 19, 19, 32, 58,
+ 74, -1, 57, 19, 19, 32, 32, 58, 74, -1,
+ 75, 76, -1, 76, -1, 104, -1, 19, 104, -1,
+ 19, 21, 104, -1, 81, -1, 82, -1, 84, -1,
+ 59, -1, 33, -1, 34, -1, 35, -1, 36, -1,
+ 19, 19, -1, 19, 55, 24, -1, 60, 120, -1,
+ 60, 55, 24, -1, 78, 79, -1, 79, 78, -1,
+ 79, -1, 78, -1, 19, -1, -1, 77, 93, 19,
+ 80, 59, -1, 77, 93, 19, 22, 80, 59, -1,
+ 38, 91, 90, 19, 83, 19, 55, 24, 19, 55,
+ 24, 59, -1, 38, 91, 90, 19, 83, 19, 55,
+ 24, 59, -1, 38, 91, 90, 19, 83, 19, -1,
+ 57, 19, 58, -1, -1, 37, 19, 19, 85, 19,
+ 55, 24, 19, 55, 24, 59, -1, 37, 19, 19,
+ 85, 19, 55, 24, 59, -1, 37, 19, 19, 85,
+ 59, -1, 57, 86, 58, -1, -1, 86, 61, 89,
+ -1, 89, -1, 32, -1, 19, 57, 32, 58, -1,
+ 120, -1, 87, -1, 42, 60, 87, -1, 43, 60,
+ 87, -1, 44, 60, 120, -1, 45, 60, 120, -1,
+ 46, 60, 88, -1, 48, 60, 92, -1, 49, 60,
+ 93, -1, 50, 60, 21, -1, 50, 60, 19, -1,
+ 51, 60, 21, -1, 51, 60, 19, -1, 52, 60,
+ 21, -1, 52, 60, 19, -1, 53, 60, 21, -1,
+ 53, 60, 19, -1, 54, 60, 21, -1, 54, 60,
+ 19, -1, 19, -1, 19, 57, 19, 93, 58, -1,
+ 19, -1, 57, 92, 58, -1, -1, 19, 62, 92,
+ -1, 19, -1, 94, 98, -1, 94, -1, 95, -1,
+ 19, -1, 5, 19, -1, 19, 5, -1, 97, 19,
+ -1, 5, 97, 19, -1, 97, 19, 5, -1, 96,
+ 95, -1, 21, 95, -1, 5, 95, -1, 21, -1,
+ 21, 5, -1, 96, -1, 96, 5, -1, 6, -1,
+ 18, -1, 14, -1, 15, -1, 13, -1, 16, -1,
+ 17, -1, 11, -1, 12, -1, 7, -1, 8, -1,
+ 9, -1, 63, -1, 63, 5, -1, 63, 98, -1,
+ 63, 5, 98, -1, 19, 101, -1, 101, -1, 77,
+ 19, 101, -1, 19, 77, 101, -1, 77, 101, -1,
+ 99, -1, 19, 57, 102, 58, -1, 102, 61, 19,
+ -1, 19, -1, 55, 24, -1, 59, -1, 40, 91,
+ 100, 93, 19, 57, 107, 58, 105, 103, -1, 77,
+ 40, 91, 99, 93, 19, 57, 107, 58, 105, 103,
+ -1, 39, 77, 93, 19, 57, 107, 58, 105, 103,
+ -1, 77, 39, 93, 19, 57, 107, 58, 105, 103,
+ -1, 39, 93, 19, 57, 107, 58, 105, 103, -1,
+ 41, 57, 21, 58, 93, 19, 57, 107, 58, 105,
+ 103, -1, 77, 93, 19, 57, 107, 58, 105, 103,
+ -1, 19, 57, 19, 58, 103, -1, 19, 106, -1,
+ 19, 106, 19, 106, -1, 19, 106, 19, 106, 19,
+ 106, -1, -1, 120, -1, 55, 24, -1, 6, -1,
+ 19, -1, 19, 5, -1, 5, 19, -1, 19, 61,
+ 108, -1, 19, 5, 61, 108, -1, 5, 19, 61,
+ 108, -1, 108, -1, 109, 61, 10, -1, 109, -1,
+ 109, 61, 110, -1, 110, -1, 93, 19, -1, 93,
+ 19, 22, -1, 93, 19, 57, 19, 111, 58, -1,
+ 93, 19, 22, 57, 19, 111, 58, -1, 111, 112,
+ -1, 112, -1, 19, -1, 64, 120, -1, 65, 120,
+ -1, 64, 60, 120, -1, 65, 60, 120, -1, 60,
+ 60, 120, -1, 66, 60, 120, -1, 9, 19, 55,
+ 114, 56, 21, 59, -1, 9, 19, 55, 114, 61,
+ 56, 21, 59, -1, 114, 61, 115, -1, 115, -1,
+ 19, 60, 120, -1, 19, -1, 48, 19, 55, 117,
+ 56, 21, 59, -1, 48, 19, 55, 117, 61, 56,
+ 21, 59, -1, 117, 61, 19, -1, 19, -1, 47,
+ 19, 55, 119, 56, 21, 59, -1, 47, 19, 55,
+ 119, 61, 56, 21, 59, -1, 119, 61, 19, -1,
+ 19, -1, 20, -1, 67, 20, -1, 23, -1, 19,
+ -1
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
-static const unsigned short int yyrline[] =
+static const yytype_uint16 yyrline[] =
{
- 0, 689, 689, 690, 691, 692, 695, 704, 713, 722,
- 731, 740, 751, 752, 753, 754, 755, 756, 757, 758,
- 761, 766, 773, 790, 791, 799, 811, 820, 832, 841,
- 850, 859, 870, 871, 874, 875, 884, 896, 897, 898,
- 899, 902, 903, 904, 905, 908, 928, 952, 956, 964,
- 965, 966, 967, 968, 976, 982, 985, 990, 1058, 1112,
- 1201, 1209, 1214, 1262, 1298, 1314, 1315, 1318, 1319, 1322,
- 1323, 1335, 1336, 1339, 1345, 1351, 1357, 1363, 1369, 1375,
- 1382, 1388, 1394, 1400, 1406, 1412, 1418, 1424, 1430, 1436,
- 1442, 1467, 1476, 1482, 1483, 1486, 1489, 1495, 1502, 1511,
- 1514, 1517, 1521, 1525, 1529, 1534, 1542, 1546, 1551, 1555,
- 1558, 1562, 1565, 1570, 1571, 1572, 1573, 1574, 1575, 1576,
- 1577, 1578, 1581, 1582, 1583, 1586, 1587, 1588, 1592, 1599,
- 1611, 1617, 1629, 1641, 1644, 1650, 1655, 1658, 1663, 1664,
- 1668, 1684, 1700, 1716, 1732, 1743, 1749, 1759, 1782, 1793,
- 1812, 1818, 1819, 1825, 1826, 1837, 1848, 1859, 1869, 1879,
- 1889, 1892, 1893, 1896, 1897, 1900, 1903, 1906, 1914, 1924,
- 1925, 1928, 1945, 1952, 1959, 1966, 1973, 1980, 1989, 1998,
- 2009, 2010, 2013, 2033, 2043, 2052, 2063, 2066, 2071, 2080,
- 2091, 2094, 2100, 2101, 2105, 2106
+ 0, 704, 704, 705, 706, 707, 710, 719, 728, 737,
+ 746, 755, 764, 773, 784, 785, 786, 787, 788, 789,
+ 790, 791, 794, 799, 806, 823, 824, 832, 844, 853,
+ 865, 874, 883, 892, 903, 904, 907, 908, 917, 929,
+ 930, 931, 932, 935, 936, 937, 938, 941, 961, 985,
+ 989, 997, 998, 999, 1000, 1001, 1009, 1015, 1018, 1023,
+ 1091, 1145, 1234, 1242, 1247, 1295, 1331, 1347, 1348, 1351,
+ 1352, 1355, 1356, 1368, 1369, 1372, 1378, 1384, 1390, 1396,
+ 1402, 1408, 1415, 1421, 1427, 1433, 1439, 1445, 1451, 1457,
+ 1463, 1469, 1475, 1500, 1509, 1515, 1516, 1519, 1522, 1528,
+ 1535, 1544, 1547, 1550, 1554, 1558, 1562, 1567, 1575, 1579,
+ 1584, 1588, 1591, 1595, 1598, 1603, 1604, 1605, 1606, 1607,
+ 1608, 1609, 1610, 1611, 1614, 1615, 1616, 1619, 1620, 1621,
+ 1625, 1632, 1644, 1650, 1662, 1674, 1677, 1683, 1688, 1691,
+ 1696, 1697, 1701, 1724, 1747, 1770, 1793, 1811, 1824, 1834,
+ 1874, 1886, 1906, 1937, 1944, 1945, 1951, 1952, 1963, 1974,
+ 1985, 1995, 2005, 2015, 2018, 2019, 2022, 2023, 2026, 2029,
+ 2032, 2040, 2050, 2051, 2054, 2071, 2078, 2085, 2092, 2099,
+ 2106, 2115, 2124, 2135, 2136, 2139, 2159, 2169, 2178, 2189,
+ 2192, 2197, 2206, 2217, 2220, 2226, 2227, 2231, 2232
};
#endif
-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "CLASS", "FROM", "CONST", "VOID",
"STRUCT", "UNION", "ENUM", "THREEDOTS", "SIGNED", "UNSIGNED", "LONG",
"SHORT", "INT", "FLOAT", "DOUBLE", "CHAR", "TOKEN", "NUMBER",
- "TYPETOKEN", "ARRAY_DIM", "SINGLE_CHAR", "CCODE", "HTCODE", "PHCODE",
- "HCODE", "ACODE", "ATCODE", "STRING", "PUBLIC", "PRIVATE", "PROTECTED",
- "CLASSWIDE", "PROPERTY", "ARGUMENT", "VIRTUAL", "SIGNAL", "OVERRIDE",
- "NICK", "BLURB", "MAXIMUM", "MINIMUM", "DEFAULT_VALUE", "ERROR", "FLAGS",
- "TYPE", "FLAGS_TYPE", "ENUM_TYPE", "PARAM_TYPE", "BOXED_TYPE",
- "OBJECT_TYPE", "'{'", "'}'", "'('", "')'", "';'", "'='", "','", "'|'",
- "'*'", "'>'", "'<'", "'!'", "'-'", "$accept", "prog", "ccode", "ccodes",
- "class", "classdec", "classflags", "classcode", "thing", "scope",
- "destructor", "initializer", "varoptions", "variable", "argument",
- "export", "property", "param_spec", "param_spec_list", "string",
- "anyval", "param_spec_value", "argtype", "flags", "flaglist", "type",
- "specifier_list", "spec_list", "specifier", "strunionenum", "pointer",
- "simplesigtype", "fullsigtype", "sigtype", "tokenlist", "codenocode",
- "method", "returnvals", "retcode", "funcargs", "arglist", "arglist1",
- "arg", "checklist", "check", "enumcode", "enumvals", "enumval",
- "flagcode", "flagvals", "errorcode", "errorvals", "numtok", 0
+ "TYPETOKEN", "ARRAY_DIM", "SINGLE_CHAR", "CCODE", "CTCODE", "ADCODE",
+ "HTCODE", "PHCODE", "HCODE", "ACODE", "ATCODE", "STRING", "PUBLIC",
+ "PRIVATE", "PROTECTED", "CLASSWIDE", "PROPERTY", "ARGUMENT", "VIRTUAL",
+ "SIGNAL", "OVERRIDE", "NICK", "BLURB", "MAXIMUM", "MINIMUM",
+ "DEFAULT_VALUE", "ERROR", "FLAGS", "TYPE", "FLAGS_TYPE", "ENUM_TYPE",
+ "PARAM_TYPE", "BOXED_TYPE", "OBJECT_TYPE", "'{'", "'}'", "'('", "')'",
+ "';'", "'='", "','", "'|'", "'*'", "'>'", "'<'", "'!'", "'-'", "$accept",
+ "prog", "ccode", "ccodes", "class", "classdec", "classflags",
+ "classcode", "thing", "scope", "destructor", "initializer", "varoptions",
+ "variable", "argument", "export", "property", "param_spec",
+ "param_spec_list", "string", "anyval", "param_spec_value", "argtype",
+ "flags", "flaglist", "type", "specifier_list", "spec_list", "specifier",
+ "strunionenum", "pointer", "simplesigtype", "fullsigtype", "sigtype",
+ "tokenlist", "codenocode", "method", "methodmods", "retcode", "funcargs",
+ "arglist", "arglist1", "arg", "checklist", "check", "enumcode",
+ "enumvals", "enumval", "flagcode", "flagvals", "errorcode", "errorvals",
+ "numtok", 0
};
#endif
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
-static const unsigned short int yytoknum[] =
+static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
- 305, 306, 307, 123, 125, 40, 41, 59, 61, 44,
- 124, 42, 62, 60, 33, 45
+ 305, 306, 307, 308, 309, 123, 125, 40, 41, 59,
+ 61, 44, 124, 42, 62, 60, 33, 45
};
# endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const unsigned char yyr1[] =
+static const yytype_uint8 yyr1[] =
{
- 0, 66, 67, 67, 67, 67, 68, 68, 68, 68,
- 68, 68, 69, 69, 69, 69, 69, 69, 69, 69,
- 70, 70, 71, 72, 72, 72, 72, 72, 72, 72,
- 72, 72, 73, 73, 74, 74, 74, 74, 74, 74,
- 74, 75, 75, 75, 75, 76, 76, 77, 77, 78,
- 78, 78, 78, 78, 78, 79, 79, 80, 80, 80,
- 81, 81, 82, 82, 82, 83, 83, 84, 84, 85,
- 85, 86, 86, 87, 87, 87, 87, 87, 87, 87,
- 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
- 87, 88, 88, 89, 89, 90, 90, 91, 91, 92,
- 92, 92, 92, 92, 92, 92, 93, 93, 93, 93,
- 93, 93, 93, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 95, 95, 95, 96, 96, 96, 96, 97,
- 97, 98, 98, 98, 98, 99, 100, 100, 101, 101,
- 102, 102, 102, 102, 102, 102, 102, 102, 103, 103,
- 103, 104, 104, 105, 105, 105, 105, 105, 105, 105,
- 105, 106, 106, 107, 107, 108, 108, 108, 108, 109,
- 109, 110, 110, 110, 110, 110, 110, 110, 111, 111,
- 112, 112, 113, 113, 114, 114, 115, 115, 116, 116,
- 117, 117, 118, 118, 118, 118
+ 0, 68, 69, 69, 69, 69, 70, 70, 70, 70,
+ 70, 70, 70, 70, 71, 71, 71, 71, 71, 71,
+ 71, 71, 72, 72, 73, 74, 74, 74, 74, 74,
+ 74, 74, 74, 74, 75, 75, 76, 76, 76, 76,
+ 76, 76, 76, 77, 77, 77, 77, 78, 78, 79,
+ 79, 80, 80, 80, 80, 80, 80, 81, 81, 82,
+ 82, 82, 83, 83, 84, 84, 84, 85, 85, 86,
+ 86, 87, 87, 88, 88, 89, 89, 89, 89, 89,
+ 89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+ 89, 89, 89, 90, 90, 91, 91, 92, 92, 93,
+ 93, 94, 94, 94, 94, 94, 94, 94, 95, 95,
+ 95, 95, 95, 95, 95, 96, 96, 96, 96, 96,
+ 96, 96, 96, 96, 97, 97, 97, 98, 98, 98,
+ 98, 99, 99, 100, 100, 100, 100, 101, 102, 102,
+ 103, 103, 104, 104, 104, 104, 104, 104, 104, 104,
+ 105, 105, 105, 105, 106, 106, 107, 107, 107, 107,
+ 107, 107, 107, 107, 108, 108, 109, 109, 110, 110,
+ 110, 110, 111, 111, 112, 112, 112, 112, 112, 112,
+ 112, 113, 113, 114, 114, 115, 115, 116, 116, 117,
+ 117, 118, 118, 119, 119, 120, 120, 120, 120
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
-static const unsigned char yyr2[] =
+static const yytype_uint8 yyr2[] =
{
0, 2, 3, 2, 2, 1, 1, 1, 1, 1,
- 1, 1, 2, 2, 2, 2, 1, 1, 1, 1,
- 4, 3, 5, 0, 4, 5, 5, 5, 6, 7,
- 6, 7, 2, 1, 1, 2, 3, 1, 1, 1,
- 1, 1, 1, 1, 1, 2, 3, 2, 3, 2,
- 2, 1, 1, 1, 0, 5, 6, 12, 9, 6,
- 3, 0, 11, 8, 5, 3, 0, 3, 1, 1,
- 4, 1, 1, 3, 3, 3, 3, 3, 3, 3,
+ 1, 1, 1, 1, 2, 2, 2, 2, 1, 1,
+ 1, 1, 4, 3, 5, 0, 4, 5, 5, 5,
+ 6, 7, 6, 7, 2, 1, 1, 2, 3, 1,
+ 1, 1, 1, 1, 1, 1, 1, 2, 3, 2,
+ 3, 2, 2, 1, 1, 1, 0, 5, 6, 12,
+ 9, 6, 3, 0, 11, 8, 5, 3, 0, 3,
+ 1, 1, 4, 1, 1, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 1, 5, 1, 3, 0, 3, 1, 2, 1, 1,
- 1, 2, 2, 2, 3, 3, 2, 2, 2, 1,
- 2, 1, 2, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 2, 2, 3, 2,
- 1, 3, 3, 2, 1, 4, 3, 1, 2, 1,
- 10, 11, 9, 9, 8, 11, 8, 5, 2, 4,
- 0, 1, 2, 1, 1, 2, 2, 3, 4, 4,
- 1, 3, 1, 3, 1, 2, 3, 6, 7, 2,
- 1, 1, 2, 2, 3, 3, 3, 3, 7, 8,
- 3, 1, 3, 1, 7, 8, 3, 1, 7, 8,
- 3, 1, 1, 2, 1, 1
+ 3, 3, 1, 5, 1, 3, 0, 3, 1, 2,
+ 1, 1, 1, 2, 2, 2, 3, 3, 2, 2,
+ 2, 1, 2, 1, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
+ 3, 2, 1, 3, 3, 2, 1, 4, 3, 1,
+ 2, 1, 10, 11, 9, 9, 8, 11, 8, 5,
+ 2, 4, 6, 0, 1, 2, 1, 1, 2, 2,
+ 3, 4, 4, 1, 3, 1, 3, 1, 2, 3,
+ 6, 7, 2, 1, 1, 2, 2, 3, 3, 3,
+ 3, 7, 8, 3, 1, 3, 1, 7, 8, 3,
+ 1, 7, 8, 3, 1, 1, 2, 1, 1
};
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
means the default is an error. */
-static const unsigned char yydefact[] =
+static const yytype_uint8 yydefact[] =
{
- 0, 0, 0, 6, 8, 9, 7, 10, 11, 0,
- 0, 0, 16, 0, 5, 0, 17, 18, 19, 0,
- 0, 0, 0, 1, 12, 4, 13, 14, 15, 3,
- 0, 0, 0, 0, 0, 2, 0, 41, 42, 43,
- 44, 0, 94, 0, 94, 0, 21, 40, 0, 33,
- 0, 37, 38, 39, 34, 23, 183, 0, 181, 191,
- 0, 187, 0, 0, 0, 0, 0, 35, 0, 0,
- 0, 0, 113, 122, 123, 124, 120, 121, 117, 115,
- 116, 118, 119, 114, 100, 109, 0, 0, 98, 99,
- 111, 0, 0, 0, 20, 32, 0, 94, 0, 0,
- 22, 0, 0, 0, 0, 0, 0, 0, 36, 0,
- 0, 66, 96, 0, 92, 0, 0, 101, 108, 0,
- 102, 110, 107, 0, 0, 125, 97, 112, 106, 103,
- 0, 0, 134, 0, 130, 0, 0, 0, 54, 0,
- 195, 192, 194, 0, 182, 0, 0, 180, 0, 190,
- 0, 0, 186, 0, 0, 0, 0, 0, 0, 93,
- 0, 61, 104, 0, 0, 126, 127, 105, 0, 0,
- 0, 129, 0, 133, 0, 0, 0, 0, 0, 53,
- 54, 0, 0, 52, 51, 0, 0, 0, 0, 0,
- 23, 193, 178, 0, 188, 0, 184, 0, 0, 139,
- 147, 90, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 68, 0, 64, 95, 0,
- 0, 0, 0, 0, 113, 100, 0, 0, 160, 162,
- 164, 128, 137, 0, 132, 131, 0, 0, 0, 0,
- 45, 0, 0, 0, 0, 47, 49, 0, 50, 55,
- 0, 23, 23, 23, 0, 24, 179, 189, 185, 138,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 65, 0, 0, 0, 0, 59, 0, 101,
- 102, 0, 165, 150, 0, 135, 0, 0, 0, 0,
- 0, 46, 56, 150, 48, 0, 23, 25, 27, 26,
- 0, 23, 0, 69, 73, 74, 75, 76, 195, 72,
- 77, 71, 78, 79, 81, 80, 83, 82, 85, 84,
- 87, 86, 89, 88, 67, 0, 91, 60, 0, 150,
- 0, 0, 157, 166, 0, 0, 0, 161, 163, 136,
- 0, 0, 150, 0, 0, 23, 30, 23, 28, 0,
- 0, 63, 0, 0, 159, 158, 0, 0, 0, 148,
- 151, 144, 150, 0, 0, 0, 146, 31, 29, 0,
- 0, 0, 58, 142, 0, 171, 0, 0, 0, 0,
- 0, 170, 152, 0, 0, 150, 143, 150, 70, 0,
- 0, 0, 0, 0, 172, 0, 173, 0, 167, 169,
- 149, 140, 0, 0, 62, 0, 168, 176, 174, 175,
- 177, 145, 141, 57
+ 0, 0, 0, 6, 13, 7, 9, 10, 8, 11,
+ 12, 0, 0, 0, 18, 0, 5, 0, 19, 20,
+ 21, 0, 0, 0, 0, 1, 14, 4, 15, 16,
+ 17, 3, 0, 0, 0, 0, 0, 2, 0, 43,
+ 44, 45, 46, 0, 96, 0, 96, 0, 23, 42,
+ 0, 35, 0, 39, 40, 41, 36, 25, 186, 0,
+ 184, 194, 0, 190, 0, 0, 0, 0, 0, 37,
+ 0, 0, 0, 0, 115, 124, 125, 126, 122, 123,
+ 119, 117, 118, 120, 121, 116, 102, 111, 0, 0,
+ 100, 101, 113, 0, 0, 0, 22, 34, 0, 96,
+ 0, 0, 24, 0, 0, 0, 0, 0, 0, 0,
+ 38, 0, 0, 68, 98, 0, 94, 0, 0, 103,
+ 110, 0, 104, 112, 109, 0, 0, 127, 99, 114,
+ 108, 105, 0, 0, 136, 0, 132, 0, 0, 0,
+ 56, 0, 198, 195, 197, 0, 185, 0, 0, 183,
+ 0, 193, 0, 0, 189, 0, 0, 0, 0, 0,
+ 0, 95, 0, 63, 106, 0, 0, 128, 129, 107,
+ 0, 0, 0, 131, 0, 135, 0, 0, 0, 0,
+ 0, 55, 56, 0, 0, 54, 53, 0, 0, 0,
+ 0, 0, 25, 196, 181, 0, 191, 0, 187, 0,
+ 0, 141, 149, 92, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 70, 0, 66,
+ 97, 0, 0, 0, 0, 0, 115, 102, 0, 0,
+ 163, 165, 167, 130, 139, 0, 134, 133, 0, 0,
+ 0, 0, 47, 0, 0, 0, 0, 49, 51, 0,
+ 52, 57, 0, 25, 25, 25, 0, 26, 182, 192,
+ 188, 140, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 67, 0, 0, 0, 0, 61,
+ 0, 103, 104, 0, 168, 153, 0, 137, 0, 0,
+ 0, 0, 0, 48, 58, 153, 50, 0, 25, 27,
+ 29, 28, 0, 25, 0, 71, 75, 76, 77, 78,
+ 198, 74, 79, 73, 80, 81, 83, 82, 85, 84,
+ 87, 86, 89, 88, 91, 90, 69, 0, 93, 62,
+ 0, 153, 0, 0, 160, 169, 0, 0, 0, 164,
+ 166, 138, 0, 0, 153, 0, 0, 25, 32, 25,
+ 30, 0, 0, 65, 0, 0, 162, 161, 0, 0,
+ 0, 150, 154, 146, 153, 0, 0, 0, 148, 33,
+ 31, 0, 0, 0, 60, 144, 0, 174, 0, 0,
+ 0, 0, 0, 173, 155, 0, 0, 153, 145, 153,
+ 72, 0, 0, 0, 0, 0, 175, 0, 176, 0,
+ 170, 172, 151, 142, 0, 0, 64, 0, 171, 179,
+ 177, 178, 180, 0, 147, 143, 59, 152
};
-/* YYDEFGOTO[NTERM-NUM]. */
-static const short int yydefgoto[] =
+/* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int16 yydefgoto[] =
{
- -1, 11, 12, 13, 14, 15, 100, 48, 49, 50,
- 183, 184, 185, 51, 52, 221, 53, 157, 214, 304,
- 310, 215, 115, 70, 113, 226, 88, 89, 90, 91,
- 126, 132, 133, 134, 233, 200, 54, 336, 359, 227,
- 228, 229, 230, 380, 381, 16, 57, 58, 17, 62,
- 18, 60, 360
+ -1, 13, 14, 15, 16, 17, 102, 50, 51, 52,
+ 185, 186, 187, 53, 54, 223, 55, 159, 216, 306,
+ 312, 217, 117, 72, 115, 228, 90, 91, 92, 93,
+ 128, 134, 135, 136, 235, 202, 56, 338, 361, 229,
+ 230, 231, 232, 382, 383, 18, 59, 60, 19, 64,
+ 20, 62, 362
};
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
-#define YYPACT_NINF -325
-static const short int yypact[] =
+#define YYPACT_NINF -360
+static const yytype_int16 yypact[] =
{
- 144, -5, 92, -325, -325, -325, -325, -325, -325, 98,
- 99, 123, -325, 144, 167, 78, -325, -325, -325, 161,
- 121, 154, 182, -325, -325, 167, -325, -325, -325, 167,
- 148, 179, 217, 227, 228, 167, 211, -325, -325, -325,
- -325, 237, 229, 326, 229, 234, -325, -325, 184, -325,
- 292, -325, -325, -325, -325, 263, 261, -31, -325, -325,
- 147, -325, 174, 268, 283, 309, 292, -325, 317, 330,
- 331, 373, -325, -325, -325, -325, -325, -325, -325, -325,
- -325, -325, -325, -325, 346, 441, 390, 333, 294, -325,
- 455, 334, 293, 335, -325, -325, 390, 229, 357, 364,
- -325, 75, 372, 38, 379, 50, 389, 95, -325, 298,
- 398, 393, 367, 378, 394, 425, 469, -325, -325, 431,
- -325, 469, -325, 432, 408, 5, -325, 469, -325, 459,
- 220, 446, -325, 390, -325, 421, 460, 470, 156, 178,
- -325, -325, -325, 458, -325, 434, 467, -325, 435, -325,
- 472, 437, -325, 474, 202, 442, 221, 39, 330, -325,
- 477, 443, -325, 444, 407, 294, -325, -325, 445, 482,
- 483, -325, -6, -325, 484, 390, 449, -6, 390, 101,
- 31, 407, 15, 447, 487, 450, -15, 452, 453, 480,
- 263, -325, -325, 454, -325, 456, -325, 457, 488, -325,
- -325, -325, 461, 462, 463, 464, 465, 466, 468, 471,
- 473, 475, 476, 478, -23, -325, 479, -325, -325, 390,
- 496, 497, 407, 424, 481, 14, 498, 485, -325, 486,
- -325, -325, -325, 201, -325, -325, 489, 499, 407, 506,
- -325, 503, 490, 492, 504, -325, -325, 101, -325, -325,
- 100, 263, 263, 263, 104, -325, -325, -325, -325, -325,
- 2, 2, 75, 75, 7, 330, 390, 208, 266, 269,
- 274, 327, -325, 221, 511, 493, 494, 500, 495, 222,
- 223, 390, 87, 519, 356, -325, 520, 407, 491, 501,
- 505, -325, -325, 519, -325, 502, 263, -325, -325, -325,
- 507, 263, 509, -325, -325, -325, -325, -325, 509, -325,
- -325, -325, -325, -325, -325, -325, -325, -325, -325, -325,
- -325, -325, -325, -325, -325, 58, -325, -325, 516, 519,
- 390, 390, -325, 510, 523, 32, 202, -325, -325, -325,
- 512, 407, 519, 407, 202, 263, -325, 263, -325, 513,
- 508, -325, 71, 202, -325, -325, 533, 88, 530, 536,
- -325, -325, 519, 514, 202, 515, -325, -325, -325, 517,
- 532, 521, -325, -325, 88, -325, 518, 64, 83, 522,
- 63, -325, -325, 32, 202, 519, -325, 519, -325, 524,
- 535, 81, 75, 75, -325, 75, -325, 75, -325, -325,
- -325, -325, 202, 202, -325, 525, -325, -325, -325, -325,
- -325, -325, -325, -325
+ 162, -2, 6, -360, -360, -360, -360, -360, -360, -360,
+ -360, 16, 90, 131, -360, 162, 210, 77, -360, -360,
+ -360, 156, 126, 160, 167, -360, -360, 210, -360, -360,
+ -360, 210, 161, 223, 153, 230, 231, 210, 226, -360,
+ -360, -360, -360, 244, 207, 309, 207, 214, -360, -360,
+ 192, -360, 292, -360, -360, -360, -360, 215, 242, -28,
+ -360, -360, 151, -360, 152, 255, 300, 310, 292, -360,
+ 319, 330, 336, 376, -360, -360, -360, -360, -360, -360,
+ -360, -360, -360, -360, -360, -360, 351, 444, 393, 338,
+ 295, -360, 458, 360, 327, 365, -360, -360, 393, 207,
+ 377, 384, -360, 7, 392, 92, 399, 98, 409, 100,
+ -360, 379, 428, 394, 390, 395, 397, 447, 472, -360,
+ -360, 448, -360, 472, -360, 449, 423, 5, -360, 472,
+ -360, 476, 149, 463, -360, 393, -360, 433, 473, 475,
+ 58, 184, -360, -360, -360, 477, -360, 436, 478, -360,
+ 437, -360, 479, 439, -360, 480, 159, 445, 236, -4,
+ 330, -360, 484, 450, -360, 451, 410, 295, -360, -360,
+ 452, 485, 486, -360, 69, -360, 487, 393, 453, 69,
+ 393, 115, -3, 410, 18, 454, 492, 456, 117, 455,
+ 459, 488, 215, -360, -360, 457, -360, 460, -360, 462,
+ 494, -360, -360, -360, 464, 465, 466, 467, 468, 469,
+ 470, 471, 474, 481, 482, 483, 185, -360, 489, -360,
+ -360, 393, 493, 503, 410, 427, 490, 8, 504, 491,
+ -360, 495, -360, -360, -360, 212, -360, -360, 496, 513,
+ 410, 514, -360, 511, 498, 497, 512, -360, -360, 115,
+ -360, -360, 120, 215, 215, 215, 121, -360, -360, -360,
+ -360, -360, 110, 110, 7, 7, 63, 330, 393, 119,
+ 202, 235, 274, 333, -360, 236, 515, 500, 501, 499,
+ 502, 289, 290, 393, -8, 518, 359, -360, 519, 410,
+ 505, 506, 508, -360, -360, 518, -360, 509, 215, -360,
+ -360, -360, 510, 215, 516, -360, -360, -360, -360, -360,
+ 516, -360, -360, -360, -360, -360, -360, -360, -360, -360,
+ -360, -360, -360, -360, -360, -360, -360, 13, -360, -360,
+ 521, 518, 393, 393, -360, 517, 527, 70, 159, -360,
+ -360, -360, 520, 410, 518, 410, 159, 215, -360, 215,
+ -360, 529, 522, -360, 65, 159, -360, -360, 528, 32,
+ 526, 532, -360, -360, 518, 523, 159, 524, -360, -360,
+ -360, 525, 539, 530, -360, -360, 32, -360, 531, 27,
+ 83, 533, 56, -360, -360, 70, 159, 518, -360, 518,
+ -360, 507, 545, 81, 7, 7, -360, 7, -360, 7,
+ -360, -360, 551, -360, 159, 159, -360, 535, -360, -360,
+ -360, -360, -360, 70, -360, -360, -360, -360
};
/* YYPGOTO[NTERM-NUM]. */
-static const short int yypgoto[] =
+static const yytype_int16 yypgoto[] =
{
- -325, -325, 103, 110, 549, -325, -188, -325, 527, -25,
- 382, 347, 387, -325, -325, -325, -325, -325, -325, 22,
- -325, 296, -325, -35, -153, -42, -325, -68, -325, -65,
- -94, 440, -325, -84, -325, -324, -22, -286, 189, -177,
- -256, -325, 295, 204, -154, 175, -325, 526, 196, -325,
- 245, -325, -101
+ -360, -360, 21, 15, 537, -360, -190, -360, 534, -27,
+ 354, 386, 398, -360, -360, -360, -360, -360, -360, -90,
+ -360, 297, -360, -37, -155, -44, -360, -70, -360, -67,
+ -23, 440, -360, -5, -360, -326, 85, -288, -278, -179,
+ -262, -360, 301, 199, -359, 237, -360, 536, 238, -360,
+ 322, -360, -103
};
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
-#define YYTABLE_NINF -157
-static const short int yytable[] =
+#define YYTABLE_NINF -160
+static const yytype_int16 yytable[] =
{
- 144, 87, 255, 118, 243, 218, 119, 344, 98, 92,
- 165, 66, 361, 168, 67, 250, 19, 122, 86, 280,
- 366, 302, 128, 102, 110, 332, 308, 141, 103, 373,
- 142, 166, 303, 272, 140, 141, 273, 303, 142, 66,
- 386, 251, 108, 353, 123, 278, 171, 173, 118, 169,
- 179, 140, 141, 118, 136, 142, 364, 56, 216, 118,
- 401, 289, 137, 297, 298, 299, 125, 131, 244, 149,
- -154, 231, 143, 281, 354, 355, 384, 350, 411, 412,
- 143, 245, 375, 140, 141, 358, 234, 142, 235, 182,
- 371, 174, 146, 171, 140, 141, 217, 143, 142, 402,
- 375, 403, 140, 141, 150, 170, 142, 375, 346, 333,
- 340, 20, 312, 348, 152, 351, 24, 21, 22, 398,
- 240, 376, 393, 23, 29, 377, 378, 379, 372, 143,
- 295, 30, 24, 237, 300, 35, 239, 406, 24, 376,
- 143, 395, 334, 377, 378, 379, 376, 1, 143, 153,
- 377, 378, 379, 2, 241, 118, 296, 367, 119, 368,
- 301, 306, 307, 311, 363, 31, 365, 36, 3, 4,
- 5, 6, 7, 8, 32, 179, 2, 275, 180, 37,
- 38, 39, 40, 41, 42, 43, 44, 45, 26, 9,
- 10, 3, 4, 5, 6, 7, 8, 186, 187, 188,
- 55, 104, 46, 36, 26, 47, 105, 33, 189, 27,
- 26, 181, 9, 10, 182, 37, 38, 39, 40, 41,
- 42, 43, 44, 45, 313, 27, 399, 314, 106, 315,
- 63, 27, 64, 107, 190, 34, 56, 399, 94, 168,
- 201, 47, 37, 38, 39, 40, 59, 61, 43, 44,
- 45, 37, 38, 39, 40, 198, 68, 285, 28, 199,
- 286, 202, 203, 204, 205, 206, 65, 207, 208, 209,
- 210, 211, 212, 213, 28, 169, 394, 396, -156, -155,
- 28, 330, 331, 305, 69, 316, 309, 317, 318, 93,
- 319, 407, 408, 320, 409, 321, 410, 71, 72, 73,
- 74, 75, 63, 76, 77, 78, 79, 80, 81, 82,
- 83, 84, 130, 85, 37, 38, 39, 40, 99, 101,
- 43, 44, 45, 65, 37, 38, 39, 40, 109, 96,
- 97, 71, 72, 73, 74, 75, 111, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, 322, 85, 323, 112,
- 114, 120, 124, 129, 154, 125, 135, 37, 38, 39,
- 40, 71, 72, 73, 74, 75, 337, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, 138, 85, 116, 72,
- 73, 74, 75, 139, 76, 77, 78, 79, 80, 81,
- 82, 83, 117, 145, 85, 71, 72, 73, 74, 75,
- 148, 76, 77, 78, 79, 80, 81, 82, 83, 84,
- 151, 85, 223, 224, 73, 74, 75, 155, 76, 77,
- 78, 79, 80, 81, 82, 83, 225, 158, 85, 116,
- 72, 73, 74, 75, 159, 76, 77, 78, 79, 80,
- 81, 82, 83, 279, 161, 85, 121, 72, 156, 160,
- 162, 163, 76, 77, 78, 79, 80, 81, 82, 83,
- 127, 72, 85, 164, 167, 172, 76, 77, 78, 79,
- 80, 81, 82, 83, 116, 72, 85, 175, 191, 176,
- 76, 77, 78, 79, 80, 81, 82, 83, 193, 177,
- 85, 192, 194, 195, 196, 197, 219, 181, 220, 222,
- 169, 232, 168, 236, 238, 182, 247, 249, 252, 253,
- 254, 256, 259, 257, 258, 276, 277, 282, 288, 260,
- 261, 262, 263, 264, 265, 290, 266, 291, 294, 267,
- 246, 268, 274, 269, 270, 325, 271, -153, 335, 339,
- 352, 283, 357, 369, 287, 284, 341, 292, 293, 326,
- 327, 329, 374, 328, 382, 383, 389, 342, 345, 405,
- 343, 370, 25, 347, 349, 356, 248, 242, 362, 324,
- 385, 387, 400, 388, 390, 95, 392, 178, 391, 338,
- 397, 404, 413, 0, 0, 0, 0, 0, 0, 0,
+ 146, 89, 257, 120, 245, 220, 121, 346, 100, 94,
+ 167, 68, 363, 282, 335, 218, 181, 124, 88, 21,
+ 368, 334, 130, 401, 112, 22, 142, 143, 104, 375,
+ 144, 31, 352, 105, 401, 23, 26, 142, 143, 68,
+ 388, 144, 37, 355, 125, 280, 142, 143, 120, 336,
+ 144, 377, 26, 120, 138, 219, 366, 184, 26, 120,
+ 403, 291, 139, 299, 300, 301, -157, 133, 127, 283,
+ 356, 357, 353, 246, 145, 377, 386, 181, 414, 415,
+ 182, 247, 310, 143, 373, 145, 144, 395, 170, 142,
+ 143, 176, 378, 144, 145, 305, 379, 380, 381, 404,
+ 377, 405, 142, 143, 168, 172, 144, 402, 348, 24,
+ 342, 58, 314, 350, 400, 183, 378, 151, 184, 154,
+ 379, 380, 381, 69, 374, 360, 171, 173, 175, 304,
+ 145, 25, 32, 239, 242, 417, 241, 145, 316, 408,
+ 317, 378, 305, 397, 233, 379, 380, 381, 148, 252,
+ 145, 110, 297, 302, 152, 120, 155, 369, 121, 370,
+ 33, 308, 309, 313, 365, 1, 367, 236, 170, 237,
+ 243, 2, 58, 307, 173, 253, 311, 277, 298, 303,
+ 38, 34, 39, 40, 41, 42, 3, 4, 5, 6,
+ 7, 8, 9, 10, 39, 40, 41, 42, 43, 44,
+ 45, 46, 47, 188, 189, 190, 171, 106, 108, 11,
+ 12, 38, 107, 109, 200, 35, 191, 48, 201, 2,
+ 49, 318, 36, 319, 315, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 3, 4, 5, 6, 7, 8,
+ 9, 10, 192, 274, 57, 65, 275, 66, 96, 61,
+ 63, 49, 28, 29, 320, 203, 321, 11, 12, 39,
+ 40, 41, 42, 70, 71, 45, 46, 47, 28, 29,
+ 287, 95, 101, 288, 28, 29, 396, 398, 204, 205,
+ 206, 207, 208, 67, 209, 210, 211, 212, 213, 214,
+ 215, 409, 410, 322, 411, 323, 412, 73, 74, 75,
+ 76, 77, 103, 78, 79, 80, 81, 82, 83, 84,
+ 85, 86, 67, 87, 73, 74, 75, 76, 77, 65,
+ 78, 79, 80, 81, 82, 83, 84, 85, 86, 111,
+ 87, 98, 99, 39, 40, 41, 42, 30, 113, 45,
+ 46, 47, 39, 40, 41, 42, 132, -159, -158, 114,
+ 332, 333, 324, 30, 325, 116, 122, 126, 127, 30,
+ 39, 40, 41, 42, 73, 74, 75, 76, 77, 339,
+ 78, 79, 80, 81, 82, 83, 84, 85, 86, 131,
+ 87, 118, 74, 75, 76, 77, 137, 78, 79, 80,
+ 81, 82, 83, 84, 85, 119, 140, 87, 73, 74,
+ 75, 76, 77, 141, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 147, 87, 225, 226, 75, 76, 77,
+ 150, 78, 79, 80, 81, 82, 83, 84, 85, 227,
+ 153, 87, 118, 74, 75, 76, 77, 156, 78, 79,
+ 80, 81, 82, 83, 84, 85, 281, 157, 87, 123,
+ 74, 158, 160, 161, 162, 78, 79, 80, 81, 82,
+ 83, 84, 85, 129, 74, 87, 163, 164, 165, 78,
+ 79, 80, 81, 82, 83, 84, 85, 118, 74, 87,
+ 166, 169, 174, 78, 79, 80, 81, 82, 83, 84,
+ 85, 177, 178, 87, 179, 194, 196, 193, 198, 195,
+ 197, 199, 183, 221, 234, 170, 238, 222, 224, 171,
+ 240, 249, 278, 254, 184, 251, 258, 255, 261, 259,
+ 256, 260, 279, 284, 262, 263, 264, 265, 266, 267,
+ 268, 269, 290, 292, 270, 293, 296, 337, 341, 327,
+ 250, 271, 272, 273, 276, 354, 359, 376, -156, 285,
+ 384, 385, 27, 289, 330, 295, 286, 294, 328, 329,
+ 331, 371, 343, 391, 344, 345, 406, 347, 349, 407,
+ 413, 248, 326, 351, 358, 393, 0, 372, 364, 180,
+ 244, 387, 389, 390, 97, 392, 0, 340, 0, 0,
+ 0, 394, 0, 399, 416, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 147
+ 0, 149
};
-static const short int yycheck[] =
+static const yytype_int16 yycheck[] =
{
- 101, 43, 190, 71, 181, 158, 71, 293, 50, 44,
- 5, 36, 336, 19, 36, 30, 21, 85, 43, 5,
- 344, 19, 90, 54, 66, 281, 19, 20, 59, 353,
- 23, 125, 30, 56, 19, 20, 59, 30, 23, 64,
- 364, 56, 64, 329, 86, 222, 130, 131, 116, 55,
- 19, 19, 20, 121, 96, 23, 342, 19, 19, 127,
- 384, 238, 97, 251, 252, 253, 61, 92, 53, 19,
- 56, 165, 65, 59, 330, 331, 362, 19, 402, 403,
- 65, 182, 19, 19, 20, 53, 170, 23, 172, 58,
- 19, 133, 54, 177, 19, 20, 57, 65, 23, 385,
- 19, 387, 19, 20, 54, 130, 23, 19, 296, 22,
- 287, 19, 265, 301, 19, 57, 13, 19, 19, 56,
- 19, 58, 58, 0, 14, 62, 63, 64, 57, 65,
- 30, 53, 29, 175, 30, 25, 178, 56, 35, 58,
- 65, 58, 55, 62, 63, 64, 58, 3, 65, 54,
- 62, 63, 64, 9, 53, 223, 56, 345, 223, 347,
- 56, 262, 263, 264, 341, 4, 343, 19, 24, 25,
- 26, 27, 28, 29, 53, 19, 9, 219, 22, 31,
- 32, 33, 34, 35, 36, 37, 38, 39, 13, 45,
- 46, 24, 25, 26, 27, 28, 29, 19, 20, 21,
- 21, 54, 54, 19, 29, 57, 59, 53, 30, 13,
- 35, 55, 45, 46, 58, 31, 32, 33, 34, 35,
- 36, 37, 38, 39, 266, 29, 380, 19, 54, 21,
- 19, 35, 21, 59, 56, 53, 19, 391, 54, 19,
- 19, 57, 31, 32, 33, 34, 19, 19, 37, 38,
- 39, 31, 32, 33, 34, 53, 19, 56, 13, 57,
- 59, 40, 41, 42, 43, 44, 55, 46, 47, 48,
- 49, 50, 51, 52, 29, 55, 377, 378, 56, 56,
- 35, 59, 59, 261, 55, 19, 264, 21, 19, 55,
- 21, 392, 393, 19, 395, 21, 397, 5, 6, 7,
- 8, 9, 19, 11, 12, 13, 14, 15, 16, 17,
- 18, 19, 19, 21, 31, 32, 33, 34, 55, 58,
- 37, 38, 39, 55, 31, 32, 33, 34, 19, 37,
- 38, 5, 6, 7, 8, 9, 19, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 19, 21, 21, 19,
- 19, 5, 19, 19, 56, 61, 21, 31, 32, 33,
- 34, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 103, 45, 192, 73, 183, 160, 73, 295, 52, 46,
+ 5, 38, 338, 5, 22, 19, 19, 87, 45, 21,
+ 346, 283, 92, 382, 68, 19, 19, 20, 56, 355,
+ 23, 16, 19, 61, 393, 19, 15, 19, 20, 66,
+ 366, 23, 27, 331, 88, 224, 19, 20, 118, 57,
+ 23, 19, 31, 123, 98, 59, 344, 60, 37, 129,
+ 386, 240, 99, 253, 254, 255, 58, 94, 63, 61,
+ 332, 333, 59, 55, 67, 19, 364, 19, 404, 405,
+ 22, 184, 19, 20, 19, 67, 23, 60, 19, 19,
+ 20, 135, 60, 23, 67, 32, 64, 65, 66, 387,
+ 19, 389, 19, 20, 127, 132, 23, 385, 298, 19,
+ 289, 19, 267, 303, 58, 57, 60, 19, 60, 19,
+ 64, 65, 66, 38, 59, 55, 57, 132, 133, 19,
+ 67, 0, 55, 177, 19, 413, 180, 67, 19, 58,
+ 21, 60, 32, 60, 167, 64, 65, 66, 56, 32,
+ 67, 66, 32, 32, 56, 225, 56, 347, 225, 349,
+ 4, 264, 265, 266, 343, 3, 345, 172, 19, 174,
+ 55, 9, 19, 263, 179, 58, 266, 221, 58, 58,
+ 19, 55, 33, 34, 35, 36, 24, 25, 26, 27,
+ 28, 29, 30, 31, 33, 34, 35, 36, 37, 38,
+ 39, 40, 41, 19, 20, 21, 57, 56, 56, 47,
+ 48, 19, 61, 61, 55, 55, 32, 56, 59, 9,
+ 59, 19, 55, 21, 268, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 24, 25, 26, 27, 28, 29,
+ 30, 31, 58, 58, 21, 19, 61, 21, 56, 19,
+ 19, 59, 15, 15, 19, 19, 21, 47, 48, 33,
+ 34, 35, 36, 19, 57, 39, 40, 41, 31, 31,
+ 58, 57, 57, 61, 37, 37, 379, 380, 42, 43,
+ 44, 45, 46, 57, 48, 49, 50, 51, 52, 53,
+ 54, 394, 395, 19, 397, 21, 399, 5, 6, 7,
+ 8, 9, 60, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 57, 21, 5, 6, 7, 8, 9, 19,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 19,
+ 21, 39, 40, 33, 34, 35, 36, 15, 19, 39,
+ 40, 41, 33, 34, 35, 36, 19, 58, 58, 19,
+ 61, 61, 19, 31, 21, 19, 5, 19, 63, 37,
+ 33, 34, 35, 36, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 19,
+ 21, 5, 6, 7, 8, 9, 21, 11, 12, 13,
14, 15, 16, 17, 18, 19, 19, 21, 5, 6,
7, 8, 9, 19, 11, 12, 13, 14, 15, 16,
17, 18, 19, 21, 21, 5, 6, 7, 8, 9,
21, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 21, 21, 5, 6, 7, 8, 9, 19, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 60, 21, 5,
- 6, 7, 8, 9, 56, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 19, 21, 5, 6, 55, 55,
- 19, 19, 11, 12, 13, 14, 15, 16, 17, 18,
- 5, 6, 21, 55, 5, 19, 11, 12, 13, 14,
- 15, 16, 17, 18, 5, 6, 21, 56, 20, 19,
- 11, 12, 13, 14, 15, 16, 17, 18, 21, 19,
- 21, 57, 57, 21, 57, 21, 19, 55, 55, 55,
- 55, 19, 19, 19, 55, 58, 19, 57, 56, 56,
- 30, 57, 24, 57, 57, 19, 19, 19, 19, 58,
- 58, 58, 58, 58, 58, 19, 58, 24, 24, 58,
- 183, 58, 53, 58, 58, 24, 58, 56, 19, 19,
- 24, 56, 19, 30, 55, 59, 55, 57, 56, 56,
- 56, 56, 19, 53, 24, 19, 24, 56, 56, 24,
- 55, 53, 13, 56, 55, 55, 184, 180, 56, 273,
- 56, 56, 383, 56, 53, 48, 58, 137, 374, 284,
- 58, 57, 57, -1, -1, -1, -1, -1, -1, -1,
+ 21, 21, 5, 6, 7, 8, 9, 58, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 19, 21, 5,
+ 6, 57, 62, 58, 57, 11, 12, 13, 14, 15,
+ 16, 17, 18, 5, 6, 21, 19, 19, 19, 11,
+ 12, 13, 14, 15, 16, 17, 18, 5, 6, 21,
+ 57, 5, 19, 11, 12, 13, 14, 15, 16, 17,
+ 18, 58, 19, 21, 19, 59, 59, 20, 59, 21,
+ 21, 21, 57, 19, 19, 19, 19, 57, 57, 57,
+ 57, 19, 19, 58, 60, 59, 59, 58, 24, 59,
+ 32, 59, 19, 19, 60, 60, 60, 60, 60, 60,
+ 60, 60, 19, 19, 60, 24, 24, 19, 19, 24,
+ 186, 60, 60, 60, 55, 24, 19, 19, 58, 58,
+ 24, 19, 15, 57, 55, 58, 61, 59, 58, 58,
+ 58, 32, 57, 24, 58, 57, 59, 58, 58, 24,
+ 19, 185, 275, 57, 57, 376, -1, 55, 58, 139,
+ 182, 58, 58, 58, 50, 55, -1, 286, -1, -1,
+ -1, 60, -1, 60, 59, -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,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 103
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 105
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
-static const unsigned char yystos[] =
+static const yytype_uint8 yystos[] =
{
- 0, 3, 9, 24, 25, 26, 27, 28, 29, 45,
- 46, 67, 68, 69, 70, 71, 111, 114, 116, 21,
- 19, 19, 19, 0, 68, 70, 111, 114, 116, 69,
- 53, 4, 53, 53, 53, 69, 19, 31, 32, 33,
- 34, 35, 36, 37, 38, 39, 54, 57, 73, 74,
- 75, 79, 80, 82, 102, 21, 19, 112, 113, 19,
- 117, 19, 115, 19, 21, 55, 75, 102, 19, 55,
- 89, 5, 6, 7, 8, 9, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 21, 75, 91, 92, 93,
- 94, 95, 89, 55, 54, 74, 37, 38, 91, 55,
- 72, 58, 54, 59, 54, 59, 54, 59, 102, 19,
- 91, 19, 19, 90, 19, 88, 5, 19, 93, 95,
- 5, 5, 93, 91, 19, 61, 96, 5, 93, 19,
- 19, 75, 97, 98, 99, 21, 91, 89, 19, 19,
- 19, 20, 23, 65, 118, 21, 54, 113, 21, 19,
- 54, 21, 19, 54, 56, 19, 55, 83, 60, 56,
- 55, 19, 19, 19, 55, 5, 96, 5, 19, 55,
- 75, 99, 19, 99, 91, 56, 19, 19, 97, 19,
- 22, 55, 58, 76, 77, 78, 19, 20, 21, 30,
- 56, 20, 57, 21, 57, 21, 57, 21, 53, 57,
- 101, 19, 40, 41, 42, 43, 44, 46, 47, 48,
- 49, 50, 51, 52, 84, 87, 19, 57, 90, 19,
- 55, 81, 55, 5, 6, 19, 91, 105, 106, 107,
- 108, 96, 19, 100, 99, 99, 19, 91, 55, 91,
- 19, 53, 78, 105, 53, 118, 77, 19, 76, 57,
- 30, 56, 56, 56, 30, 72, 57, 57, 57, 24,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 56, 59, 53, 91, 19, 19, 105, 19,
- 5, 59, 19, 56, 59, 56, 59, 55, 19, 105,
- 19, 24, 57, 56, 24, 30, 56, 72, 72, 72,
- 30, 56, 19, 30, 85, 85, 118, 118, 19, 85,
- 86, 118, 90, 91, 19, 21, 19, 21, 19, 21,
- 19, 21, 19, 21, 87, 24, 56, 56, 53, 56,
- 59, 59, 106, 22, 55, 19, 103, 10, 108, 19,
- 105, 55, 56, 55, 103, 56, 72, 56, 72, 55,
- 19, 57, 24, 103, 106, 106, 55, 19, 53, 104,
- 118, 101, 56, 105, 103, 105, 101, 72, 72, 30,
- 53, 19, 57, 101, 19, 19, 58, 62, 63, 64,
- 109, 110, 24, 19, 103, 56, 101, 56, 56, 24,
- 53, 109, 58, 58, 118, 58, 118, 58, 56, 110,
- 104, 101, 103, 103, 57, 24, 56, 118, 118, 118,
- 118, 101, 101, 57
+ 0, 3, 9, 24, 25, 26, 27, 28, 29, 30,
+ 31, 47, 48, 69, 70, 71, 72, 73, 113, 116,
+ 118, 21, 19, 19, 19, 0, 70, 72, 113, 116,
+ 118, 71, 55, 4, 55, 55, 55, 71, 19, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 56, 59,
+ 75, 76, 77, 81, 82, 84, 104, 21, 19, 114,
+ 115, 19, 119, 19, 117, 19, 21, 57, 77, 104,
+ 19, 57, 91, 5, 6, 7, 8, 9, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 21, 77, 93,
+ 94, 95, 96, 97, 91, 57, 56, 76, 39, 40,
+ 93, 57, 74, 60, 56, 61, 56, 61, 56, 61,
+ 104, 19, 93, 19, 19, 92, 19, 90, 5, 19,
+ 95, 97, 5, 5, 95, 93, 19, 63, 98, 5,
+ 95, 19, 19, 77, 99, 100, 101, 21, 93, 91,
+ 19, 19, 19, 20, 23, 67, 120, 21, 56, 115,
+ 21, 19, 56, 21, 19, 56, 58, 19, 57, 85,
+ 62, 58, 57, 19, 19, 19, 57, 5, 98, 5,
+ 19, 57, 77, 101, 19, 101, 93, 58, 19, 19,
+ 99, 19, 22, 57, 60, 78, 79, 80, 19, 20,
+ 21, 32, 58, 20, 59, 21, 59, 21, 59, 21,
+ 55, 59, 103, 19, 42, 43, 44, 45, 46, 48,
+ 49, 50, 51, 52, 53, 54, 86, 89, 19, 59,
+ 92, 19, 57, 83, 57, 5, 6, 19, 93, 107,
+ 108, 109, 110, 98, 19, 102, 101, 101, 19, 93,
+ 57, 93, 19, 55, 80, 107, 55, 120, 79, 19,
+ 78, 59, 32, 58, 58, 58, 32, 74, 59, 59,
+ 59, 24, 60, 60, 60, 60, 60, 60, 60, 60,
+ 60, 60, 60, 60, 58, 61, 55, 93, 19, 19,
+ 107, 19, 5, 61, 19, 58, 61, 58, 61, 57,
+ 19, 107, 19, 24, 59, 58, 24, 32, 58, 74,
+ 74, 74, 32, 58, 19, 32, 87, 87, 120, 120,
+ 19, 87, 88, 120, 92, 93, 19, 21, 19, 21,
+ 19, 21, 19, 21, 19, 21, 89, 24, 58, 58,
+ 55, 58, 61, 61, 108, 22, 57, 19, 105, 10,
+ 110, 19, 107, 57, 58, 57, 105, 58, 74, 58,
+ 74, 57, 19, 59, 24, 105, 108, 108, 57, 19,
+ 55, 106, 120, 103, 58, 107, 105, 107, 103, 74,
+ 74, 32, 55, 19, 59, 103, 19, 19, 60, 64,
+ 65, 66, 111, 112, 24, 19, 105, 58, 103, 58,
+ 58, 24, 55, 111, 60, 60, 120, 60, 120, 60,
+ 58, 112, 106, 103, 105, 105, 59, 24, 58, 120,
+ 120, 120, 120, 19, 103, 103, 59, 106
};
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
-#endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# endif
-#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
-#endif
-
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
/* Like YYERROR except do call yyerror. This remains here temporarily
to ease the transition to the new meaning of YYERROR, for GCC.
- Once GCC version 2 has supplanted version 1, this can go. */
+ Once GCC version 2 has supplanted version 1, this can go. However,
+ YYFAIL appears to be in use. Nevertheless, it is formally deprecated
+ in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+ discussed. */
#define YYFAIL goto yyerrlab
+#if defined YYFAIL
+ /* This is here to suppress warnings from the GCC cpp's
+ -Wunused-macros. Normally we don't worry about that warning, but
+ some users do, and we want to make it easy for users to remove
+ YYFAIL uses, which will produce warnings from Bison 2.5. */
+#endif
#define YYRECOVERING() (!!yyerrstatus)
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
- YYPOPSTACK; \
+ YYPOPSTACK (1); \
goto yybackup; \
} \
else \
- { \
- yyerror ("syntax error: cannot back up");\
+ { \
+ yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
-while (0)
+while (YYID (0))
#define YYTERROR 1
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
- if (N) \
+ if (YYID (N)) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
- while (0)
+ while (YYID (0))
#endif
we won't break user code: when these are the locations we know. */
#ifndef YY_LOCATION_PRINT
-# if YYLTYPE_IS_TRIVIAL
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
# define YY_LOCATION_PRINT(File, Loc) \
fprintf (File, "%d.%d-%d.%d", \
- (Loc).first_line, (Loc).first_column, \
- (Loc).last_line, (Loc).last_column)
+ (Loc).first_line, (Loc).first_column, \
+ (Loc).last_line, (Loc).last_column)
# else
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
do { \
if (yydebug) \
YYFPRINTF Args; \
-} while (0)
+} while (YYID (0))
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yysymprint (stderr, \
- Type, Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (0)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+ FILE *yyoutput;
+ int yytype;
+ YYSTYPE const * const yyvaluep;
+#endif
+{
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+ YYUSE (yyoutput);
+# endif
+ switch (yytype)
+ {
+ default:
+ break;
+ }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep)
+ FILE *yyoutput;
+ int yytype;
+ YYSTYPE const * const yyvaluep;
+#endif
+{
+ if (yytype < YYNTOKENS)
+ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ else
+ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+ yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+ YYFPRINTF (yyoutput, ")");
+}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static void
-yy_stack_print (short int *bottom, short int *top)
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
-yy_stack_print (bottom, top)
- short int *bottom;
- short int *top;
+yy_stack_print (yybottom, yytop)
+ yytype_int16 *yybottom;
+ yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
- for (/* Nothing. */; bottom <= top; ++bottom)
- YYFPRINTF (stderr, " %d", *bottom);
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
YYFPRINTF (stderr, "\n");
}
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
-} while (0)
+} while (YYID (0))
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static void
-yy_reduce_print (int yyrule)
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
-yy_reduce_print (yyrule)
+yy_reduce_print (yyvsp, yyrule)
+ YYSTYPE *yyvsp;
int yyrule;
#endif
{
+ int yynrhs = yyr2[yyrule];
int yyi;
- unsigned int yylno = yyrline[yyrule];
- YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
- yyrule - 1, yylno);
- /* Print the symbols being reduced, and their result. */
- for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
- YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
- YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+ unsigned long int yylno = yyrline[yyrule];
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ );
+ YYFPRINTF (stderr, "\n");
+ }
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
- yy_reduce_print (Rule); \
-} while (0)
+ yy_reduce_print (yyvsp, Rule); \
+} while (YYID (0))
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
- SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
#if YYERROR_VERBOSE
# ifndef yystrlen
-# if defined (__GLIBC__) && defined (_STRING_H)
+# if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
-# if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
-# else
+#else
+static YYSIZE_T
yystrlen (yystr)
- const char *yystr;
-# endif
+ const char *yystr;
+#endif
{
- register const char *yys = yystr;
-
- while (*yys++ != '\0')
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
continue;
-
- return yys - yystr - 1;
+ return yylen;
}
# endif
# endif
# ifndef yystpcpy
-# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+# 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. */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static char *
-# if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
-# else
-yystpcpy (yydest, yysrc)
- char *yydest;
- const char *yysrc;
-# endif
+#else
+static char *
+yystpcpy (yydest, yysrc)
+ char *yydest;
+ const char *yysrc;
+#endif
{
- register char *yyd = yydest;
- register const char *yys = yysrc;
+ char *yyd = yydest;
+ const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
# endif
# endif
-#endif /* !YYERROR_VERBOSE */
+# 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 YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYSIZE_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;
+ /* Fall through. */
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
-\f
+ if (! yyres)
+ return yystrlen (yystr);
-#if YYDEBUG
-/*--------------------------------.
-| Print this symbol on YYOUTPUT. |
-`--------------------------------*/
+ return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
-#if defined (__STDC__) || defined (__cplusplus)
-static void
-yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yysymprint (yyoutput, yytype, yyvaluep)
- FILE *yyoutput;
- int yytype;
- YYSTYPE *yyvaluep;
-#endif
+/* Copy into YYRESULT an error message about the unexpected token
+ YYCHAR while in state YYSTATE. Return the number of bytes copied,
+ including the terminating null byte. If YYRESULT is null, do not
+ copy anything; just return the number of bytes that would be
+ copied. As a special case, return 0 if an ordinary "syntax error"
+ message will do. Return YYSIZE_MAXIMUM if overflow occurs during
+ size calculation. */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
{
- /* Pacify ``unused variable'' warnings. */
- (void) yyvaluep;
+ int yyn = yypact[yystate];
- if (yytype < YYNTOKENS)
- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+ return 0;
else
- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-
-# ifdef YYPRINT
- if (yytype < YYNTOKENS)
- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# endif
- switch (yytype)
{
- default:
- break;
+ int yytype = YYTRANSLATE (yychar);
+ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+ YYSIZE_T yysize = yysize0;
+ YYSIZE_T yysize1;
+ int yysize_overflow = 0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ int yyx;
+
+# if 0
+ /* This is so xgettext sees the translatable formats that are
+ constructed on the fly. */
+ YY_("syntax error, unexpected %s");
+ YY_("syntax error, unexpected %s, expecting %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+ char *yyfmt;
+ char const *yyf;
+ static char const yyunexpected[] = "syntax error, unexpected %s";
+ static char const yyexpecting[] = ", expecting %s";
+ static char const yyor[] = " or %s";
+ char yyformat[sizeof yyunexpected
+ + sizeof yyexpecting - 1
+ + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+ * (sizeof yyor - 1))];
+ char const *yyprefix = yyexpecting;
+
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ 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 yycount = 1;
+
+ yyarg[0] = yytname[yytype];
+ yyfmt = yystpcpy (yyformat, yyunexpected);
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ yyformat[sizeof yyunexpected - 1] = '\0';
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+ yysize_overflow |= (yysize1 < yysize);
+ yysize = yysize1;
+ yyfmt = yystpcpy (yyfmt, yyprefix);
+ yyprefix = yyor;
+ }
+
+ yyf = YY_(yyformat);
+ yysize1 = yysize + yystrlen (yyf);
+ yysize_overflow |= (yysize1 < yysize);
+ yysize = yysize1;
+
+ if (yysize_overflow)
+ return YYSIZE_MAXIMUM;
+
+ if (yyresult)
+ {
+ /* 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 = yyresult;
+ int yyi = 0;
+ while ((*yyp = *yyf) != '\0')
+ {
+ if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyf += 2;
+ }
+ else
+ {
+ yyp++;
+ yyf++;
+ }
+ }
+ }
+ return yysize;
}
- YYFPRINTF (yyoutput, ")");
}
+#endif /* YYERROR_VERBOSE */
+\f
-#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
-#if defined (__STDC__) || defined (__cplusplus)
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
YYSTYPE *yyvaluep;
#endif
{
- /* Pacify ``unused variable'' warnings. */
- (void) yyvaluep;
+ YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
{
default:
- break;
+ break;
}
}
-\f
/* Prevent warnings from -Wmissing-prototypes. */
-
#ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
+#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
-# else
+#else
int yyparse ();
-# endif
+#endif
#else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
+#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
#endif /* ! YYPARSE_PARAM */
-
-/* The look-ahead symbol. */
+/* The lookahead symbol. */
int yychar;
-/* The semantic value of the look-ahead symbol. */
+/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;
/* Number of syntax errors so far. */
-/*----------.
-| yyparse. |
-`----------*/
+/*-------------------------.
+| yyparse or yypush_parse. |
+`-------------------------*/
#ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
-int yyparse (void *YYPARSE_PARAM)
-# else
-int yyparse (YYPARSE_PARAM)
- void *YYPARSE_PARAM;
-# endif
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+ void *YYPARSE_PARAM;
+#endif
#else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
#endif
#endif
{
-
- register int yystate;
- register int yyn;
- int yyresult;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
- /* Look-ahead token as an internal (translated) token number. */
- int yytoken = 0;
- /* Three stacks and their tools:
- `yyss': related to states,
- `yyvs': related to semantic values,
- `yyls': related to locations.
- Refer to the stacks thru separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
- /* The state stack. */
- short int yyssa[YYINITDEPTH];
- short int *yyss = yyssa;
- register short int *yyssp;
+ /* The stacks and their tools:
+ `yyss': related to states.
+ `yyvs': related to semantic values.
- /* The semantic value stack. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs = yyvsa;
- register YYSTYPE *yyvsp;
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
-#define YYPOPSTACK (yyvsp--, yyssp--)
-
- YYSIZE_T yystacksize = YYINITDEPTH;
+ YYSIZE_T yystacksize;
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#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;
- /* When reducing, the number of symbols on the RHS of the reduced
- rule. */
- int yylen;
+ yytoken = 0;
+ yyss = yyssa;
+ yyvs = yyvsa;
+ yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
+ yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
-
yyssp = yyss;
yyvsp = yyvs;
-
- yyvsp[0] = yylval;
-
goto yysetstate;
/*------------------------------------------------------------.
`------------------------------------------------------------*/
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.
- */
+ have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
yysetstate:
#ifdef 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
memory. */
YYSTYPE *yyvs1 = yyvs;
- short int *yyss1 = yyss;
-
+ yytype_int16 *yyss1 = yyss;
/* 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 ("parser stack overflow",
+ yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
-
&yystacksize);
yyss = yyss1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
- goto yyoverflowlab;
+ goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
- goto yyoverflowlab;
+ goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
- short int *yyss1 = yyss;
+ yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
- goto yyoverflowlab;
- YYSTACK_RELOCATE (yyss);
- YYSTACK_RELOCATE (yyvs);
-
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
-
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
goto yybackup;
/*-----------.
`-----------*/
yybackup:
-/* Do appropriate processing given the current state. */
-/* Read a look-ahead token if we need one and don't already have one. */
-/* yyresume: */
-
- /* First try to decide what to do without reference to look-ahead token. */
+ /* 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 (yyn == YYPACT_NINF)
goto yydefault;
- /* Not known => get a look-ahead token if don't already have one. */
+ /* Not known => get a lookahead token if don't already have one. */
- /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
goto yyreduce;
}
- if (yyn == YYFINAL)
- YYACCEPT;
-
- /* Shift the look-ahead token. */
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
- /* Discard the token being shifted unless it is eof. */
- if (yychar != YYEOF)
- yychar = YYEMPTY;
-
- *++yyvsp = yylval;
-
-
/* 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);
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+
yystate = yyn;
+ *++yyvsp = yylval;
+
goto yynewstate;
switch (yyn)
{
case 2:
-#line 689 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 704 "parse.y"
{ ; }
break;
case 3:
-#line 690 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 705 "parse.y"
{ ; }
break;
case 4:
-#line 691 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 706 "parse.y"
{ ; }
break;
case 5:
-#line 692 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 707 "parse.y"
{ ; }
break;
case 6:
-#line 695 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 710 "parse.y"
{
Node *node = node_new (CCODE_NODE,
"cctype", C_CCODE,
- "cbuf:steal", ((yyvsp[0].cbuf))->str,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
"line_no", ccode_line,
NULL);
nodes = g_list_append(nodes,node);
- g_string_free((yyvsp[0].cbuf),FALSE);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
}
break;
case 7:
-#line 704 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 719 "parse.y"
{
Node *node = node_new (CCODE_NODE,
- "cctype", H_CCODE,
- "cbuf:steal", ((yyvsp[0].cbuf))->str,
+ "cctype", AD_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
"line_no", ccode_line,
NULL);
nodes = g_list_append(nodes,node);
- g_string_free((yyvsp[0].cbuf),FALSE);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
}
break;
case 8:
-#line 713 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 728 "parse.y"
{
Node *node = node_new (CCODE_NODE,
- "cctype", HT_CCODE,
- "cbuf:steal", ((yyvsp[0].cbuf))->str,
+ "cctype", H_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
"line_no", ccode_line,
NULL);
nodes = g_list_append(nodes,node);
- g_string_free((yyvsp[0].cbuf),FALSE);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
}
break;
case 9:
-#line 722 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 737 "parse.y"
{
Node *node = node_new (CCODE_NODE,
- "cctype", PH_CCODE,
- "cbuf:steal", ((yyvsp[0].cbuf))->str,
+ "cctype", HT_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
"line_no", ccode_line,
NULL);
nodes = g_list_append(nodes,node);
- g_string_free((yyvsp[0].cbuf),FALSE);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
}
break;
case 10:
-#line 731 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 746 "parse.y"
{
Node *node = node_new (CCODE_NODE,
- "cctype", A_CCODE,
- "cbuf:steal", ((yyvsp[0].cbuf))->str,
+ "cctype", PH_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
"line_no", ccode_line,
NULL);
nodes = g_list_append(nodes,node);
- g_string_free((yyvsp[0].cbuf),FALSE);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
}
break;
case 11:
-#line 740 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 755 "parse.y"
{
Node *node = node_new (CCODE_NODE,
- "cctype", AT_CCODE,
- "cbuf:steal", ((yyvsp[0].cbuf))->str,
+ "cctype", A_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
"line_no", ccode_line,
NULL);
nodes = g_list_append(nodes,node);
- g_string_free((yyvsp[0].cbuf),FALSE);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
}
break;
case 12:
-#line 751 "parse.y"
- { ; }
+
+/* Line 1464 of yacc.c */
+#line 764 "parse.y"
+ {
+ Node *node = node_new (CCODE_NODE,
+ "cctype", AT_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
+ "line_no", ccode_line,
+ NULL);
+ nodes = g_list_append(nodes,node);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
+ }
break;
case 13:
-#line 752 "parse.y"
- { ; }
+
+/* Line 1464 of yacc.c */
+#line 773 "parse.y"
+ {
+ Node *node = node_new (CCODE_NODE,
+ "cctype", CT_CCODE,
+ "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
+ "line_no", ccode_line,
+ NULL);
+ nodes = g_list_append(nodes,node);
+ g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
+ }
break;
case 14:
-#line 753 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 784 "parse.y"
{ ; }
break;
case 15:
-#line 754 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 785 "parse.y"
{ ; }
break;
case 16:
-#line 755 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 786 "parse.y"
{ ; }
break;
case 17:
-#line 756 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 787 "parse.y"
{ ; }
break;
case 18:
-#line 757 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 788 "parse.y"
{ ; }
break;
case 19:
-#line 758 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 789 "parse.y"
{ ; }
break;
case 20:
-#line 761 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 790 "parse.y"
+ { ; }
+ break;
+
+ case 21:
+
+/* Line 1464 of yacc.c */
+#line 791 "parse.y"
+ { ; }
+ break;
+
+ case 22:
+
+/* Line 1464 of yacc.c */
+#line 794 "parse.y"
{
((Class *)class)->nodes = class_nodes;
class_nodes = NULL;
}
break;
- case 21:
-#line 766 "parse.y"
+ case 23:
+
+/* Line 1464 of yacc.c */
+#line 799 "parse.y"
{
((Class *)class)->nodes = NULL;
class_nodes = NULL;
}
break;
- case 22:
-#line 773 "parse.y"
+ case 24:
+
+/* Line 1464 of yacc.c */
+#line 806 "parse.y"
{
class = node_new (CLASS_NODE,
- "otype:steal", (yyvsp[-3].id),
- "ptype:steal", (yyvsp[-1].id),
+ "otype:steal", (yyvsp[(2) - (5)].id),
+ "ptype:steal", (yyvsp[(4) - (5)].id),
"bonobo_object_class:steal", bonobo_object_class,
"glade_xml", glade_xml,
"interfaces:steal", interfaces,
}
break;
- case 24:
-#line 791 "parse.y"
+ case 26:
+
+/* Line 1464 of yacc.c */
+#line 824 "parse.y"
{
- if(strcmp((yyvsp[-2].id),"abstract") == 0) {
+ if(strcmp((yyvsp[(2) - (4)].id),"abstract") == 0) {
abstract = TRUE;
} else {
yyerror(_("parse error"));
}
break;
- case 25:
-#line 799 "parse.y"
+ case 27:
+
+/* Line 1464 of yacc.c */
+#line 832 "parse.y"
{
- if(strcmp((yyvsp[-3].id),"chunks") == 0) {
+ if(strcmp((yyvsp[(2) - (5)].id),"chunks") == 0) {
g_free (chunk_size);
- chunk_size = g_strdup((yyvsp[-2].id));
- } else if(strcmp((yyvsp[-3].id),"BonoboObject") == 0) {
+ chunk_size = g_strdup((yyvsp[(3) - (5)].id));
+ } else if(strcmp((yyvsp[(2) - (5)].id),"BonoboObject") == 0) {
g_free (bonobo_object_class);
- bonobo_object_class = g_strdup((yyvsp[-2].id));
+ bonobo_object_class = g_strdup((yyvsp[(3) - (5)].id));
} else {
yyerror(_("parse error"));
YYERROR;
}
break;
- case 26:
-#line 811 "parse.y"
+ case 28:
+
+/* Line 1464 of yacc.c */
+#line 844 "parse.y"
{
- if (strcmp ((yyvsp[-3].id), "interface") == 0) {
+ if (strcmp ((yyvsp[(2) - (5)].id), "interface") == 0) {
interfaces = g_list_append (interfaces,
- g_strdup ((yyvsp[-2].id)));
+ g_strdup ((yyvsp[(3) - (5)].id)));
} else {
yyerror(_("parse error"));
YYERROR;
}
break;
- case 27:
-#line 820 "parse.y"
+ case 29:
+
+/* Line 1464 of yacc.c */
+#line 853 "parse.y"
{
- if(strcmp((yyvsp[-3].id),"chunks") == 0) {
+ if(strcmp((yyvsp[(2) - (5)].id),"chunks") == 0) {
g_free (chunk_size);
- if(atoi((yyvsp[-2].id)) != 0)
- chunk_size = g_strdup((yyvsp[-2].id));
+ if(atoi((yyvsp[(3) - (5)].id)) != 0)
+ chunk_size = g_strdup((yyvsp[(3) - (5)].id));
else
chunk_size = NULL;
} else {
}
break;
- case 28:
-#line 832 "parse.y"
+ case 30:
+
+/* Line 1464 of yacc.c */
+#line 865 "parse.y"
{
- if (strcmp ((yyvsp[-4].id), "GladeXML") == 0) {
+ if (strcmp ((yyvsp[(2) - (6)].id), "GladeXML") == 0) {
glade_xml = TRUE;
- add_construct_glade((yyvsp[-3].id), (yyvsp[-2].id), NULL);
+ add_construct_glade((yyvsp[(3) - (6)].id), (yyvsp[(4) - (6)].id), NULL);
} else {
yyerror(_("parse error"));
YYERROR;
}
break;
- case 29:
-#line 841 "parse.y"
+ case 31:
+
+/* Line 1464 of yacc.c */
+#line 874 "parse.y"
{
- if (strcmp ((yyvsp[-5].id), "GladeXML") == 0) {
+ if (strcmp ((yyvsp[(2) - (7)].id), "GladeXML") == 0) {
glade_xml = TRUE;
- add_construct_glade((yyvsp[-4].id), (yyvsp[-3].id), (yyvsp[-2].id));
+ add_construct_glade((yyvsp[(3) - (7)].id), (yyvsp[(4) - (7)].id), (yyvsp[(5) - (7)].id));
} else {
yyerror(_("parse error"));
YYERROR;
}
break;
- case 30:
-#line 850 "parse.y"
+ case 32:
+
+/* Line 1464 of yacc.c */
+#line 883 "parse.y"
{
- if (strcmp ((yyvsp[-4].id), "GladeXML") == 0) {
+ if (strcmp ((yyvsp[(2) - (6)].id), "GladeXML") == 0) {
glade_xml = TRUE;
- add_construct_glade((yyvsp[-3].id), (yyvsp[-2].id), NULL);
+ add_construct_glade((yyvsp[(3) - (6)].id), (yyvsp[(4) - (6)].id), NULL);
} else {
yyerror(_("parse error"));
YYERROR;
}
break;
- case 31:
-#line 859 "parse.y"
+ case 33:
+
+/* Line 1464 of yacc.c */
+#line 892 "parse.y"
{
- if (strcmp ((yyvsp[-5].id), "GladeXML") == 0) {
+ if (strcmp ((yyvsp[(2) - (7)].id), "GladeXML") == 0) {
glade_xml = TRUE;
- add_construct_glade((yyvsp[-4].id), (yyvsp[-3].id), (yyvsp[-2].id));
+ add_construct_glade((yyvsp[(3) - (7)].id), (yyvsp[(4) - (7)].id), (yyvsp[(5) - (7)].id));
} else {
yyerror(_("parse error"));
YYERROR;
}
break;
- case 32:
-#line 870 "parse.y"
+ case 34:
+
+/* Line 1464 of yacc.c */
+#line 903 "parse.y"
{ ; }
break;
- case 33:
-#line 871 "parse.y"
+ case 35:
+
+/* Line 1464 of yacc.c */
+#line 904 "parse.y"
{ ; }
break;
- case 34:
-#line 874 "parse.y"
+ case 36:
+
+/* Line 1464 of yacc.c */
+#line 907 "parse.y"
{ ; }
break;
- case 35:
-#line 875 "parse.y"
+ case 37:
+
+/* Line 1464 of yacc.c */
+#line 908 "parse.y"
{
- if (strcmp ((yyvsp[-1].id), "BonoboObject") != 0) {
- g_free ((yyvsp[-1].id));
+ if (strcmp ((yyvsp[(1) - (2)].id), "BonoboObject") != 0) {
+ g_free ((yyvsp[(1) - (2)].id));
yyerror (_("parse error"));
YYERROR;
}
- g_free ((yyvsp[-1].id));
+ g_free ((yyvsp[(1) - (2)].id));
last_added_method->bonobo_object_func = TRUE;
}
break;
- case 36:
-#line 884 "parse.y"
+ case 38:
+
+/* Line 1464 of yacc.c */
+#line 917 "parse.y"
{
- if (strcmp ((yyvsp[-2].id), "interface") != 0) {
- g_free ((yyvsp[-2].id));
- g_free ((yyvsp[-1].id));
+ if (strcmp ((yyvsp[(1) - (3)].id), "interface") != 0) {
+ g_free ((yyvsp[(1) - (3)].id));
+ g_free ((yyvsp[(2) - (3)].id));
yyerror (_("parse error"));
YYERROR;
}
- g_free ((yyvsp[-2].id));
+ g_free ((yyvsp[(1) - (3)].id));
node_set ((Node *)last_added_method,
- "interface:steal", (yyvsp[-1].id),
+ "interface:steal", (yyvsp[(2) - (3)].id),
NULL);
}
break;
- case 37:
-#line 896 "parse.y"
+ case 39:
+
+/* Line 1464 of yacc.c */
+#line 929 "parse.y"
{ ; }
break;
- case 38:
-#line 897 "parse.y"
+ case 40:
+
+/* Line 1464 of yacc.c */
+#line 930 "parse.y"
{ ; }
break;
- case 39:
-#line 898 "parse.y"
+ case 41:
+
+/* Line 1464 of yacc.c */
+#line 931 "parse.y"
{ ; }
break;
- case 40:
-#line 899 "parse.y"
+ case 42:
+
+/* Line 1464 of yacc.c */
+#line 932 "parse.y"
{ ; }
break;
- case 41:
-#line 902 "parse.y"
+ case 43:
+
+/* Line 1464 of yacc.c */
+#line 935 "parse.y"
{ the_scope = PUBLIC_SCOPE; }
break;
- case 42:
-#line 903 "parse.y"
+ case 44:
+
+/* Line 1464 of yacc.c */
+#line 936 "parse.y"
{ the_scope = PRIVATE_SCOPE; }
break;
- case 43:
-#line 904 "parse.y"
+ case 45:
+
+/* Line 1464 of yacc.c */
+#line 937 "parse.y"
{ the_scope = PROTECTED_SCOPE; }
break;
- case 44:
-#line 905 "parse.y"
+ case 46:
+
+/* Line 1464 of yacc.c */
+#line 938 "parse.y"
{ the_scope = CLASS_SCOPE; }
break;
- case 45:
-#line 908 "parse.y"
+ case 47:
+
+/* Line 1464 of yacc.c */
+#line 941 "parse.y"
{
- if (strcmp ((yyvsp[-1].id), "destroywith") == 0) {
- g_free ((yyvsp[-1].id));
+ if (strcmp ((yyvsp[(1) - (2)].id), "destroywith") == 0) {
+ g_free ((yyvsp[(1) - (2)].id));
destructor_unref = FALSE;
- destructor = (yyvsp[0].id);
+ destructor = (yyvsp[(2) - (2)].id);
destructor_line = line_no;
destructor_simple = TRUE;
- } else if (strcmp ((yyvsp[-1].id), "unrefwith") == 0) {
- g_free ((yyvsp[-1].id));
+ } else if (strcmp ((yyvsp[(1) - (2)].id), "unrefwith") == 0) {
+ g_free ((yyvsp[(1) - (2)].id));
destructor_unref = TRUE;
- destructor = (yyvsp[0].id);
+ destructor = (yyvsp[(2) - (2)].id);
destructor_line = line_no;
destructor_simple = TRUE;
} else {
- g_free ((yyvsp[-1].id));
- g_free ((yyvsp[0].id));
+ g_free ((yyvsp[(1) - (2)].id));
+ g_free ((yyvsp[(2) - (2)].id));
yyerror (_("parse error"));
YYERROR;
}
}
break;
- case 46:
-#line 928 "parse.y"
+ case 48:
+
+/* Line 1464 of yacc.c */
+#line 961 "parse.y"
{
- if (strcmp ((yyvsp[-2].id), "destroy") == 0) {
- g_free((yyvsp[-2].id));
+ if (strcmp ((yyvsp[(1) - (3)].id), "destroy") == 0) {
+ g_free((yyvsp[(1) - (3)].id));
destructor_unref = FALSE;
- destructor = ((yyvsp[0].cbuf))->str;
- g_string_free((yyvsp[0].cbuf), FALSE);
+ destructor = ((yyvsp[(3) - (3)].cbuf))->str;
+ g_string_free((yyvsp[(3) - (3)].cbuf), FALSE);
destructor_line = ccode_line;
destructor_simple = FALSE;
- } else if (strcmp ((yyvsp[-2].id), "unref") == 0) {
- g_free ((yyvsp[-2].id));
+ } else if (strcmp ((yyvsp[(1) - (3)].id), "unref") == 0) {
+ g_free ((yyvsp[(1) - (3)].id));
destructor_unref = TRUE;
- destructor = ((yyvsp[0].cbuf))->str;
- g_string_free ((yyvsp[0].cbuf), FALSE);
+ destructor = ((yyvsp[(3) - (3)].cbuf))->str;
+ g_string_free ((yyvsp[(3) - (3)].cbuf), FALSE);
destructor_line = ccode_line;
destructor_simple = FALSE;
} else {
- g_free ((yyvsp[-2].id));
- g_string_free ((yyvsp[0].cbuf), TRUE);
+ g_free ((yyvsp[(1) - (3)].id));
+ g_string_free ((yyvsp[(3) - (3)].cbuf), TRUE);
yyerror (_("parse error"));
YYERROR;
}
}
break;
- case 47:
-#line 952 "parse.y"
+ case 49:
+
+/* Line 1464 of yacc.c */
+#line 985 "parse.y"
{
- initializer = (yyvsp[0].id);
+ initializer = (yyvsp[(2) - (2)].id);
initializer_line = ccode_line;
}
break;
- case 48:
-#line 956 "parse.y"
+ case 50:
+
+/* Line 1464 of yacc.c */
+#line 989 "parse.y"
{
- initializer = ((yyvsp[0].cbuf))->str;
+ initializer = ((yyvsp[(3) - (3)].cbuf))->str;
initializer_line = ccode_line;
- g_string_free((yyvsp[0].cbuf), FALSE);
+ g_string_free((yyvsp[(3) - (3)].cbuf), FALSE);
}
break;
- case 49:
-#line 964 "parse.y"
+ case 51:
+
+/* Line 1464 of yacc.c */
+#line 997 "parse.y"
{ ; }
break;
- case 50:
-#line 965 "parse.y"
+ case 52:
+
+/* Line 1464 of yacc.c */
+#line 998 "parse.y"
{ ; }
break;
- case 51:
-#line 966 "parse.y"
+ case 53:
+
+/* Line 1464 of yacc.c */
+#line 999 "parse.y"
{ destructor = NULL; }
break;
- case 52:
-#line 967 "parse.y"
+ case 54:
+
+/* Line 1464 of yacc.c */
+#line 1000 "parse.y"
{ initializer = NULL; }
break;
- case 53:
-#line 968 "parse.y"
+ case 55:
+
+/* Line 1464 of yacc.c */
+#line 1001 "parse.y"
{
- if (strcmp ((yyvsp[0].id), "GladeXML") == 0) {
+ if (strcmp ((yyvsp[(1) - (1)].id), "GladeXML") == 0) {
glade_widget = TRUE;
} else {
yyerror(_("parse error"));
}
break;
- case 54:
-#line 976 "parse.y"
+ case 56:
+
+/* Line 1464 of yacc.c */
+#line 1009 "parse.y"
{
destructor = NULL;
initializer = NULL;
}
break;
- case 55:
-#line 982 "parse.y"
+ case 57:
+
+/* Line 1464 of yacc.c */
+#line 1015 "parse.y"
{
- push_variable((yyvsp[-2].id), the_scope,(yyvsp[-4].line), NULL);
+ push_variable((yyvsp[(3) - (5)].id), the_scope,(yyvsp[(1) - (5)].line), NULL);
}
break;
- case 56:
-#line 985 "parse.y"
+ case 58:
+
+/* Line 1464 of yacc.c */
+#line 1018 "parse.y"
{
- push_variable((yyvsp[-3].id), the_scope, (yyvsp[-5].line), (yyvsp[-2].id));
+ push_variable((yyvsp[(3) - (6)].id), the_scope, (yyvsp[(1) - (6)].line), (yyvsp[(4) - (6)].id));
}
break;
- case 57:
-#line 990 "parse.y"
+ case 59:
+
+/* Line 1464 of yacc.c */
+#line 1023 "parse.y"
{
Node *node = NULL;
- if(strcmp((yyvsp[-6].id),"get")==0 &&
- strcmp((yyvsp[-3].id),"set")==0) {
+ if(strcmp((yyvsp[(6) - (12)].id),"get")==0 &&
+ strcmp((yyvsp[(9) - (12)].id),"set")==0) {
Type *type = pop_type();
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-3].id));
+ g_free ((yyvsp[(6) - (12)].id));
+ g_free ((yyvsp[(9) - (12)].id));
node = node_new (ARGUMENT_NODE,
- "gtktype:steal", (yyvsp[-9].id),
+ "gtktype:steal", (yyvsp[(3) - (12)].id),
"atype:steal", type,
- "flags:steal", (yyvsp[-10].list),
- "name:steal", (yyvsp[-8].id),
- "get:steal", ((yyvsp[-4].cbuf))->str,
- "get_line", (yyvsp[-5].line),
- "set:steal", ((yyvsp[-1].cbuf))->str,
- "set_line", (yyvsp[-2].line),
- "line_no", (yyvsp[-11].line),
+ "flags:steal", (yyvsp[(2) - (12)].list),
+ "name:steal", (yyvsp[(4) - (12)].id),
+ "get:steal", ((yyvsp[(8) - (12)].cbuf))->str,
+ "get_line", (yyvsp[(7) - (12)].line),
+ "set:steal", ((yyvsp[(11) - (12)].cbuf))->str,
+ "set_line", (yyvsp[(10) - (12)].line),
+ "line_no", (yyvsp[(1) - (12)].line),
NULL);
class_nodes = g_list_append(class_nodes,node);
- g_string_free ((yyvsp[-4].cbuf), FALSE);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
+ g_string_free ((yyvsp[(8) - (12)].cbuf), FALSE);
+ g_string_free ((yyvsp[(11) - (12)].cbuf), FALSE);
- } else if(strcmp((yyvsp[-6].id),"set")==0 &&
- strcmp((yyvsp[-3].id),"get")==0) {
+ } else if(strcmp((yyvsp[(6) - (12)].id),"set")==0 &&
+ strcmp((yyvsp[(9) - (12)].id),"get")==0) {
Type *type = pop_type();
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-3].id));
+ g_free ((yyvsp[(6) - (12)].id));
+ g_free ((yyvsp[(9) - (12)].id));
node = node_new (ARGUMENT_NODE,
- "gtktype:steal", (yyvsp[-9].id),
+ "gtktype:steal", (yyvsp[(3) - (12)].id),
"atype:steal", type,
- "flags:steal", (yyvsp[-10].list),
- "name:steal", (yyvsp[-8].id),
- "get:steal", ((yyvsp[-1].cbuf))->str,
- "get_line", (yyvsp[-2].line),
- "set:steal", ((yyvsp[-4].cbuf))->str,
- "set_line", (yyvsp[-5].line),
- "line_no", (yyvsp[-11].line),
+ "flags:steal", (yyvsp[(2) - (12)].list),
+ "name:steal", (yyvsp[(4) - (12)].id),
+ "get:steal", ((yyvsp[(11) - (12)].cbuf))->str,
+ "get_line", (yyvsp[(10) - (12)].line),
+ "set:steal", ((yyvsp[(8) - (12)].cbuf))->str,
+ "set_line", (yyvsp[(7) - (12)].line),
+ "line_no", (yyvsp[(1) - (12)].line),
NULL);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
- g_string_free ((yyvsp[-4].cbuf), FALSE);
+ g_string_free ((yyvsp[(11) - (12)].cbuf), FALSE);
+ g_string_free ((yyvsp[(8) - (12)].cbuf), FALSE);
class_nodes = g_list_append(class_nodes,node);
} else {
- g_free ((yyvsp[-9].id));
- g_free ((yyvsp[-8].id));
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-3].id));
- g_list_foreach ((yyvsp[-10].list), (GFunc)g_free, NULL);
- g_list_free ((yyvsp[-10].list));
- g_string_free ((yyvsp[-1].cbuf), TRUE);
- g_string_free ((yyvsp[-4].cbuf), TRUE);
+ g_free ((yyvsp[(3) - (12)].id));
+ g_free ((yyvsp[(4) - (12)].id));
+ g_free ((yyvsp[(6) - (12)].id));
+ g_free ((yyvsp[(9) - (12)].id));
+ g_list_foreach ((yyvsp[(2) - (12)].list), (GFunc)g_free, NULL);
+ g_list_free ((yyvsp[(2) - (12)].list));
+ g_string_free ((yyvsp[(11) - (12)].cbuf), TRUE);
+ g_string_free ((yyvsp[(8) - (12)].cbuf), TRUE);
yyerror (_("parse error"));
YYERROR;
}
- if ((yyvsp[-7].id) != NULL) {
+ if ((yyvsp[(5) - (12)].id) != NULL) {
Argument *arg = (Argument *)node;
export_accessors (arg->name,
arg->get != NULL, arg->get_line,
arg->atype,
arg->gtktype,
arg->line_no);
- g_free ((yyvsp[-7].id));
+ g_free ((yyvsp[(5) - (12)].id));
}
}
break;
- case 58:
-#line 1058 "parse.y"
+ case 60:
+
+/* Line 1464 of yacc.c */
+#line 1091 "parse.y"
{
Node *node = NULL;
- if(strcmp((yyvsp[-3].id), "get") == 0) {
+ if(strcmp((yyvsp[(6) - (9)].id), "get") == 0) {
Type *type = pop_type();
- g_free ((yyvsp[-3].id));
+ g_free ((yyvsp[(6) - (9)].id));
node = node_new (ARGUMENT_NODE,
- "gtktype:steal", (yyvsp[-6].id),
+ "gtktype:steal", (yyvsp[(3) - (9)].id),
"atype:steal", type,
- "flags:steal", (yyvsp[-7].list),
- "name:steal", (yyvsp[-5].id),
- "get:steal", ((yyvsp[-1].cbuf))->str,
- "get_line", (yyvsp[-2].line),
- "line_no", (yyvsp[-8].line),
+ "flags:steal", (yyvsp[(2) - (9)].list),
+ "name:steal", (yyvsp[(4) - (9)].id),
+ "get:steal", ((yyvsp[(8) - (9)].cbuf))->str,
+ "get_line", (yyvsp[(7) - (9)].line),
+ "line_no", (yyvsp[(1) - (9)].line),
NULL);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
+ g_string_free ((yyvsp[(8) - (9)].cbuf), FALSE);
class_nodes = g_list_append(class_nodes, node);
- } else if(strcmp((yyvsp[-3].id), "set") == 0) {
+ } else if(strcmp((yyvsp[(6) - (9)].id), "set") == 0) {
Type *type = pop_type();
- g_free ((yyvsp[-3].id));
+ g_free ((yyvsp[(6) - (9)].id));
node = node_new (ARGUMENT_NODE,
- "gtktype:steal", (yyvsp[-6].id),
+ "gtktype:steal", (yyvsp[(3) - (9)].id),
"atype:steal", type,
- "flags:steal", (yyvsp[-7].list),
- "name:steal", (yyvsp[-5].id),
- "set:steal", ((yyvsp[-1].cbuf))->str,
- "set_line", (yyvsp[-2].line),
- "line_no", (yyvsp[-8].line),
+ "flags:steal", (yyvsp[(2) - (9)].list),
+ "name:steal", (yyvsp[(4) - (9)].id),
+ "set:steal", ((yyvsp[(8) - (9)].cbuf))->str,
+ "set_line", (yyvsp[(7) - (9)].line),
+ "line_no", (yyvsp[(1) - (9)].line),
NULL);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
+ g_string_free ((yyvsp[(8) - (9)].cbuf), FALSE);
class_nodes = g_list_append (class_nodes, node);
} else {
- g_free ((yyvsp[-3].id));
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-5].id));
- g_list_foreach ((yyvsp[-7].list), (GFunc)g_free, NULL);
- g_list_free ((yyvsp[-7].list));
- g_string_free ((yyvsp[-1].cbuf), TRUE);
+ g_free ((yyvsp[(6) - (9)].id));
+ g_free ((yyvsp[(3) - (9)].id));
+ g_free ((yyvsp[(4) - (9)].id));
+ g_list_foreach ((yyvsp[(2) - (9)].list), (GFunc)g_free, NULL);
+ g_list_free ((yyvsp[(2) - (9)].list));
+ g_string_free ((yyvsp[(8) - (9)].cbuf), TRUE);
yyerror(_("parse error"));
YYERROR;
}
- if ((yyvsp[-4].id) != NULL) {
+ if ((yyvsp[(5) - (9)].id) != NULL) {
Argument *arg = (Argument *)node;
export_accessors (arg->name,
arg->get != NULL, arg->get_line,
arg->atype,
arg->gtktype,
arg->line_no);
- g_free ((yyvsp[-4].id));
+ g_free ((yyvsp[(5) - (9)].id));
}
}
break;
- case 59:
-#line 1112 "parse.y"
+ case 61:
+
+/* Line 1464 of yacc.c */
+#line 1145 "parse.y"
{
Node *node;
char *get, *set = NULL;
Type *type;
const char *root;
- if(strcmp((yyvsp[0].id), "link")!=0 &&
- strcmp((yyvsp[0].id), "stringlink")!=0 &&
- strcmp((yyvsp[0].id), "objectlink")!=0) {
- g_free((yyvsp[0].id));
- g_free((yyvsp[-3].id));
- g_free((yyvsp[-2].id));
- g_list_foreach((yyvsp[-4].list),(GFunc)g_free,NULL);
- g_list_free((yyvsp[-4].list));
+ if(strcmp((yyvsp[(6) - (6)].id), "link")!=0 &&
+ strcmp((yyvsp[(6) - (6)].id), "stringlink")!=0 &&
+ strcmp((yyvsp[(6) - (6)].id), "objectlink")!=0) {
+ g_free((yyvsp[(6) - (6)].id));
+ g_free((yyvsp[(3) - (6)].id));
+ g_free((yyvsp[(4) - (6)].id));
+ g_list_foreach((yyvsp[(2) - (6)].list),(GFunc)g_free,NULL);
+ g_list_free((yyvsp[(2) - (6)].list));
yyerror(_("parse error"));
YYERROR;
}
type = pop_type();
- var = find_var_or_die((yyvsp[-2].id), (yyvsp[-5].line));
+ var = find_var_or_die((yyvsp[(4) - (6)].id), (yyvsp[(1) - (6)].line));
if(var->scope == PRIVATE_SCOPE) {
root = "self->_priv";
} else if(var->scope == CLASS_SCOPE) {
root = "SELF_GET_CLASS(self)";
if(no_self_alias)
- error_print(GOB_ERROR, (yyvsp[-5].line),
+ error_print(GOB_ERROR, (yyvsp[(1) - (6)].line),
_("Self aliases needed when autolinking to a classwide member"));
} else {
root = "self";
}
- if(strcmp((yyvsp[0].id), "link")==0) {
+ if(strcmp((yyvsp[(6) - (6)].id), "link")==0) {
set = g_strdup_printf("%s->%s = ARG;",
- root, (yyvsp[-2].id));
- } else if(strcmp((yyvsp[0].id), "stringlink")==0) {
+ root, (yyvsp[(4) - (6)].id));
+ } else if(strcmp((yyvsp[(6) - (6)].id), "stringlink")==0) {
set = g_strdup_printf("g_free (%s->%s); "
"%s->%s = g_strdup (ARG);",
- root, (yyvsp[-2].id),
- root, (yyvsp[-2].id));
- } else if(strcmp((yyvsp[0].id), "objectlink")==0) {
+ root, (yyvsp[(4) - (6)].id),
+ root, (yyvsp[(4) - (6)].id));
+ } else if(strcmp((yyvsp[(6) - (6)].id), "objectlink")==0) {
set = g_strdup_printf(
"if (ARG != NULL) "
"g_object_ref (G_OBJECT (ARG)); "
"if (%s->%s != NULL) "
"g_object_unref (G_OBJECT (%s->%s)); "
"%s->%s = ARG;",
- root, (yyvsp[-2].id),
- root, (yyvsp[-2].id),
- root, (yyvsp[-2].id));
+ root, (yyvsp[(4) - (6)].id),
+ root, (yyvsp[(4) - (6)].id),
+ root, (yyvsp[(4) - (6)].id));
} else {
g_assert_not_reached();
}
- get = g_strdup_printf("ARG = %s->%s;", root, (yyvsp[-2].id));
+ get = g_strdup_printf("ARG = %s->%s;", root, (yyvsp[(4) - (6)].id));
- g_free ((yyvsp[0].id));
+ g_free ((yyvsp[(6) - (6)].id));
if (type == NULL)
type = (Type *)node_copy ((Node *)var->vtype);
node = node_new (ARGUMENT_NODE,
- "gtktype:steal", (yyvsp[-3].id),
+ "gtktype:steal", (yyvsp[(3) - (6)].id),
"atype:steal", type,
- "flags:steal", (yyvsp[-4].list),
- "name:steal", (yyvsp[-2].id),
+ "flags:steal", (yyvsp[(2) - (6)].list),
+ "name:steal", (yyvsp[(4) - (6)].id),
"get:steal", get,
- "get_line", (yyvsp[-5].line),
+ "get_line", (yyvsp[(1) - (6)].line),
"set:steal", set,
- "set_line", (yyvsp[-5].line),
- "line_no", (yyvsp[-5].line),
+ "set_line", (yyvsp[(1) - (6)].line),
+ "line_no", (yyvsp[(1) - (6)].line),
NULL);
- if ((yyvsp[-1].id) != NULL) {
+ if ((yyvsp[(5) - (6)].id) != NULL) {
Argument *arg = (Argument *)node;
export_accessors (arg->name,
arg->get != NULL, arg->get_line,
arg->atype,
arg->gtktype,
arg->line_no);
- g_free ((yyvsp[-1].id));
+ g_free ((yyvsp[(5) - (6)].id));
}
class_nodes = g_list_append (class_nodes, node);
}
break;
- case 60:
-#line 1201 "parse.y"
+ case 62:
+
+/* Line 1464 of yacc.c */
+#line 1234 "parse.y"
{
- if (strcmp ((yyvsp[-1].id), "export")!=0) {
- g_free ((yyvsp[-1].id));
+ if (strcmp ((yyvsp[(2) - (3)].id), "export")!=0) {
+ g_free ((yyvsp[(2) - (3)].id));
yyerror (_("parse error"));
YYERROR;
}
- (yyval.id) = (yyvsp[-1].id);
+ (yyval.id) = (yyvsp[(2) - (3)].id);
}
break;
- case 61:
-#line 1209 "parse.y"
+ case 63:
+
+/* Line 1464 of yacc.c */
+#line 1242 "parse.y"
{
(yyval.id) = NULL;
}
break;
- case 62:
-#line 1214 "parse.y"
+ case 64:
+
+/* Line 1464 of yacc.c */
+#line 1247 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "line_no", (yyvsp[-10].line),
- "gtktype:steal", debool ((yyvsp[-9].id)),
- "name:steal", (yyvsp[-8].id),
+ "line_no", (yyvsp[(1) - (11)].line),
+ "gtktype:steal", debool ((yyvsp[(2) - (11)].id)),
+ "name:steal", (yyvsp[(3) - (11)].id),
NULL);
- if (strcmp ((yyvsp[-6].id), "get") == 0 &&
- strcmp ((yyvsp[-3].id), "set") == 0) {
+ if (strcmp ((yyvsp[(5) - (11)].id), "get") == 0 &&
+ strcmp ((yyvsp[(8) - (11)].id), "set") == 0) {
node_set ((Node *)property,
- "get:steal", ((yyvsp[-4].cbuf))->str,
- "get_line", (yyvsp[-5].line),
- "set:steal", ((yyvsp[-1].cbuf))->str,
- "set_line", (yyvsp[-2].line),
+ "get:steal", ((yyvsp[(7) - (11)].cbuf))->str,
+ "get_line", (yyvsp[(6) - (11)].line),
+ "set:steal", ((yyvsp[(10) - (11)].cbuf))->str,
+ "set_line", (yyvsp[(9) - (11)].line),
NULL);
- g_string_free ((yyvsp[-4].cbuf), FALSE);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-3].id));
- } else if (strcmp ((yyvsp[-6].id), "set") == 0 &&
- strcmp ((yyvsp[-3].id), "get") == 0) {
+ g_string_free ((yyvsp[(7) - (11)].cbuf), FALSE);
+ g_string_free ((yyvsp[(10) - (11)].cbuf), FALSE);
+ g_free ((yyvsp[(5) - (11)].id));
+ g_free ((yyvsp[(8) - (11)].id));
+ } else if (strcmp ((yyvsp[(5) - (11)].id), "set") == 0 &&
+ strcmp ((yyvsp[(8) - (11)].id), "get") == 0) {
node_set ((Node *)property,
- "get:steal", ((yyvsp[-1].cbuf))->str,
- "get_line", (yyvsp[-2].line),
- "set:steal", ((yyvsp[-4].cbuf))->str,
- "set_line", (yyvsp[-5].line),
+ "get:steal", ((yyvsp[(10) - (11)].cbuf))->str,
+ "get_line", (yyvsp[(9) - (11)].line),
+ "set:steal", ((yyvsp[(7) - (11)].cbuf))->str,
+ "set_line", (yyvsp[(6) - (11)].line),
NULL);
- g_string_free ((yyvsp[-4].cbuf), FALSE);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-3].id));
+ g_string_free ((yyvsp[(7) - (11)].cbuf), FALSE);
+ g_string_free ((yyvsp[(10) - (11)].cbuf), FALSE);
+ g_free ((yyvsp[(5) - (11)].id));
+ g_free ((yyvsp[(8) - (11)].id));
} else {
- g_string_free ((yyvsp[-4].cbuf), TRUE);
- g_string_free ((yyvsp[-1].cbuf), TRUE);
- g_free ((yyvsp[-6].id));
- g_free ((yyvsp[-3].id));
+ g_string_free ((yyvsp[(7) - (11)].cbuf), TRUE);
+ g_string_free ((yyvsp[(10) - (11)].cbuf), TRUE);
+ g_free ((yyvsp[(5) - (11)].id));
+ g_free ((yyvsp[(8) - (11)].id));
node_free ((Node *)property);
property = NULL;
yyerror (_("parse error"));
}
break;
- case 63:
-#line 1262 "parse.y"
+ case 65:
+
+/* Line 1464 of yacc.c */
+#line 1295 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "line_no", (yyvsp[-7].line),
- "gtktype:steal", debool ((yyvsp[-6].id)),
- "name:steal", (yyvsp[-5].id),
+ "line_no", (yyvsp[(1) - (8)].line),
+ "gtktype:steal", debool ((yyvsp[(2) - (8)].id)),
+ "name:steal", (yyvsp[(3) - (8)].id),
NULL);
- if (strcmp ((yyvsp[-3].id), "get") == 0) {
+ if (strcmp ((yyvsp[(5) - (8)].id), "get") == 0) {
node_set ((Node *)property,
- "get:steal", ((yyvsp[-1].cbuf))->str,
- "get_line", (yyvsp[-2].line),
+ "get:steal", ((yyvsp[(7) - (8)].cbuf))->str,
+ "get_line", (yyvsp[(6) - (8)].line),
NULL);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
- g_free ((yyvsp[-3].id));
- } else if (strcmp ((yyvsp[-3].id), "set") == 0) {
+ g_string_free ((yyvsp[(7) - (8)].cbuf), FALSE);
+ g_free ((yyvsp[(5) - (8)].id));
+ } else if (strcmp ((yyvsp[(5) - (8)].id), "set") == 0) {
node_set ((Node *)property,
- "set:steal", ((yyvsp[-1].cbuf))->str,
- "set_line", (yyvsp[-2].line),
+ "set:steal", ((yyvsp[(7) - (8)].cbuf))->str,
+ "set_line", (yyvsp[(6) - (8)].line),
NULL);
- g_string_free ((yyvsp[-1].cbuf), FALSE);
- g_free ((yyvsp[-3].id));
+ g_string_free ((yyvsp[(7) - (8)].cbuf), FALSE);
+ g_free ((yyvsp[(5) - (8)].id));
} else {
- g_string_free ((yyvsp[-1].cbuf), TRUE);
- g_free ((yyvsp[-3].id));
+ g_string_free ((yyvsp[(7) - (8)].cbuf), TRUE);
+ g_free ((yyvsp[(5) - (8)].id));
node_free ((Node *)property);
property = NULL;
yyerror (_("parse error"));
}
break;
- case 64:
-#line 1298 "parse.y"
+ case 66:
+
+/* Line 1464 of yacc.c */
+#line 1331 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "line_no", (yyvsp[-4].line),
- "gtktype:steal", debool ((yyvsp[-3].id)),
- "name:steal", (yyvsp[-2].id),
+ "line_no", (yyvsp[(1) - (5)].line),
+ "gtktype:steal", debool ((yyvsp[(2) - (5)].id)),
+ "name:steal", (yyvsp[(3) - (5)].id),
NULL);
property_link_and_export ((Node *)property);
if (property != NULL) {
}
break;
- case 65:
-#line 1314 "parse.y"
+ case 67:
+
+/* Line 1464 of yacc.c */
+#line 1347 "parse.y"
{ ; }
break;
- case 66:
-#line 1315 "parse.y"
+ case 68:
+
+/* Line 1464 of yacc.c */
+#line 1348 "parse.y"
{ ; }
break;
- case 67:
-#line 1318 "parse.y"
+ case 69:
+
+/* Line 1464 of yacc.c */
+#line 1351 "parse.y"
{ ; }
break;
- case 68:
-#line 1319 "parse.y"
+ case 70:
+
+/* Line 1464 of yacc.c */
+#line 1352 "parse.y"
{ ; }
break;
- case 69:
-#line 1322 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
+ case 71:
+
+/* Line 1464 of yacc.c */
+#line 1355 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
break;
- case 70:
-#line 1323 "parse.y"
+ case 72:
+
+/* Line 1464 of yacc.c */
+#line 1356 "parse.y"
{
- if (strcmp ((yyvsp[-3].id), "_") != 0) {
- g_free ((yyvsp[-3].id));
+ if (strcmp ((yyvsp[(1) - (4)].id), "_") != 0) {
+ g_free ((yyvsp[(1) - (4)].id));
yyerror(_("parse error"));
YYERROR;
}
- g_free ((yyvsp[-3].id));
- (yyval.id) = g_strconcat ("_(", (yyvsp[-1].id), ")", NULL);
- g_free ((yyvsp[-1].id));
+ g_free ((yyvsp[(1) - (4)].id));
+ (yyval.id) = g_strconcat ("_(", (yyvsp[(3) - (4)].id), ")", NULL);
+ g_free ((yyvsp[(3) - (4)].id));
}
break;
- case 71:
-#line 1335 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
- break;
-
- case 72:
-#line 1336 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
- break;
-
case 73:
-#line 1339 "parse.y"
- {
- ensure_property ();
- node_set ((Node *)property,
- "nick:steal", (yyvsp[0].id),
- NULL);
- }
+
+/* Line 1464 of yacc.c */
+#line 1368 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
break;
case 74:
-#line 1345 "parse.y"
- {
- ensure_property ();
- node_set ((Node *)property,
- "blurb:steal", (yyvsp[0].id),
- NULL);
- }
+
+/* Line 1464 of yacc.c */
+#line 1369 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
break;
case 75:
-#line 1351 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1372 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "maximum:steal", (yyvsp[0].id),
+ "nick:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 76:
-#line 1357 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1378 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "minimum:steal", (yyvsp[0].id),
+ "blurb:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 77:
-#line 1363 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1384 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "default_value:steal", (yyvsp[0].id),
+ "maximum:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 78:
-#line 1369 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1390 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "flags:steal", (yyvsp[0].list),
+ "minimum:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 79:
-#line 1375 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1396 "parse.y"
{
- Type *type = pop_type ();
ensure_property ();
node_set ((Node *)property,
- "ptype:steal", type,
+ "default_value:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 80:
-#line 1382 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1402 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "flags:steal", (yyvsp[(3) - (3)].list),
NULL);
}
break;
case 81:
-#line 1388 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1408 "parse.y"
{
+ Type *type = pop_type ();
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "ptype:steal", type,
NULL);
}
break;
case 82:
-#line 1394 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1415 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 83:
-#line 1400 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1421 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 84:
-#line 1406 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1427 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 85:
-#line 1412 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1433 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 86:
-#line 1418 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1439 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 87:
-#line 1424 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1445 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 88:
-#line 1430 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1451 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 89:
-#line 1436 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1457 "parse.y"
{
ensure_property ();
node_set ((Node *)property,
- "extra_gtktype:steal", (yyvsp[0].id),
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
NULL);
}
break;
case 90:
-#line 1442 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1463 "parse.y"
+ {
+ ensure_property ();
+ node_set ((Node *)property,
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
+ NULL);
+ }
+ break;
+
+ case 91:
+
+/* Line 1464 of yacc.c */
+#line 1469 "parse.y"
{
ensure_property ();
- if (strcmp ((yyvsp[0].id), "override") == 0) {
- g_free((yyvsp[0].id));
+ node_set ((Node *)property,
+ "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
+ NULL);
+ }
+ break;
+
+ case 92:
+
+/* Line 1464 of yacc.c */
+#line 1475 "parse.y"
+ {
+ ensure_property ();
+ if (strcmp ((yyvsp[(1) - (1)].id), "override") == 0) {
+ g_free((yyvsp[(1) - (1)].id));
node_set ((Node *)property,
"override", TRUE,
NULL);
- } else if (strcmp ((yyvsp[0].id), "link") == 0) {
- g_free((yyvsp[0].id));
+ } else if (strcmp ((yyvsp[(1) - (1)].id), "link") == 0) {
+ g_free((yyvsp[(1) - (1)].id));
node_set ((Node *)property,
"link", TRUE,
NULL);
- } else if (strcmp ((yyvsp[0].id), "export") == 0) {
- g_free((yyvsp[0].id));
+ } else if (strcmp ((yyvsp[(1) - (1)].id), "export") == 0) {
+ g_free((yyvsp[(1) - (1)].id));
node_set ((Node *)property,
"export", TRUE,
NULL);
} else {
- g_free((yyvsp[0].id));
+ g_free((yyvsp[(1) - (1)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 91:
-#line 1467 "parse.y"
+ case 93:
+
+/* Line 1464 of yacc.c */
+#line 1500 "parse.y"
{
- if(strcmp((yyvsp[-2].id),"type")!=0) {
- g_free((yyvsp[-4].id));
- g_free((yyvsp[-2].id));
+ if(strcmp((yyvsp[(3) - (5)].id),"type")!=0) {
+ g_free((yyvsp[(1) - (5)].id));
+ g_free((yyvsp[(3) - (5)].id));
yyerror(_("parse error"));
YYERROR;
}
- (yyval.id) = debool ((yyvsp[-4].id));
+ (yyval.id) = debool ((yyvsp[(1) - (5)].id));
}
break;
- case 92:
-#line 1476 "parse.y"
+ case 94:
+
+/* Line 1464 of yacc.c */
+#line 1509 "parse.y"
{
- (yyval.id) = debool ((yyvsp[0].id));
+ (yyval.id) = debool ((yyvsp[(1) - (1)].id));
typestack = g_list_prepend(typestack,NULL);
}
break;
- case 93:
-#line 1482 "parse.y"
- { (yyval.list) = (yyvsp[-1].list); }
+ case 95:
+
+/* Line 1464 of yacc.c */
+#line 1515 "parse.y"
+ { (yyval.list) = (yyvsp[(2) - (3)].list); }
break;
- case 94:
-#line 1483 "parse.y"
+ case 96:
+
+/* Line 1464 of yacc.c */
+#line 1516 "parse.y"
{ (yyval.list) = NULL; }
break;
- case 95:
-#line 1486 "parse.y"
+ case 97:
+
+/* Line 1464 of yacc.c */
+#line 1519 "parse.y"
{
- (yyval.list) = g_list_append((yyvsp[0].list),(yyvsp[-2].id));
+ (yyval.list) = g_list_append((yyvsp[(3) - (3)].list),(yyvsp[(1) - (3)].id));
}
break;
- case 96:
-#line 1489 "parse.y"
+ case 98:
+
+/* Line 1464 of yacc.c */
+#line 1522 "parse.y"
{
- (yyval.list) = g_list_append(NULL,(yyvsp[0].id));
+ (yyval.list) = g_list_append(NULL,(yyvsp[(1) - (1)].id));
}
break;
- case 97:
-#line 1495 "parse.y"
+ case 99:
+
+/* Line 1464 of yacc.c */
+#line 1528 "parse.y"
{
Node *node = node_new (TYPE_NODE,
- "name:steal", (yyvsp[-1].id),
- "pointer:steal", (yyvsp[0].id),
+ "name:steal", (yyvsp[(1) - (2)].id),
+ "pointer:steal", (yyvsp[(2) - (2)].id),
NULL);
typestack = g_list_prepend(typestack,node);
}
break;
- case 98:
-#line 1502 "parse.y"
+ case 100:
+
+/* Line 1464 of yacc.c */
+#line 1535 "parse.y"
{
Node *node = node_new (TYPE_NODE,
- "name:steal", (yyvsp[0].id),
+ "name:steal", (yyvsp[(1) - (1)].id),
NULL);
typestack = g_list_prepend(typestack,node);
}
break;
- case 99:
-#line 1511 "parse.y"
- {
- (yyval.id) = (yyvsp[0].id);
- }
- break;
-
- case 100:
-#line 1514 "parse.y"
- {
- (yyval.id) = (yyvsp[0].id);
- }
- break;
-
case 101:
-#line 1517 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1544 "parse.y"
{
- (yyval.id) = g_strconcat("const ", (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = (yyvsp[(1) - (1)].id);
}
break;
case 102:
-#line 1521 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1547 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-1].id), " const", NULL);
- g_free((yyvsp[-1].id));
+ (yyval.id) = (yyvsp[(1) - (1)].id);
}
break;
case 103:
-#line 1525 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1550 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-1].id), " ", (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat("const ", (yyvsp[(2) - (2)].id), NULL);
+ g_free((yyvsp[(2) - (2)].id));
}
break;
case 104:
-#line 1529 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1554 "parse.y"
{
- (yyval.id) = g_strconcat("const ", (yyvsp[-1].id), " ",
- (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " const", NULL);
+ g_free((yyvsp[(1) - (2)].id));
}
break;
case 105:
-#line 1534 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1558 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-2].id), " ",
- (yyvsp[-1].id), " const", NULL);
- g_free((yyvsp[-1].id));
+ (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " ", (yyvsp[(2) - (2)].id), NULL);
+ g_free((yyvsp[(2) - (2)].id));
}
break;
case 106:
-#line 1542 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1562 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-1].id), " ", (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat("const ", (yyvsp[(2) - (3)].id), " ",
+ (yyvsp[(3) - (3)].id), NULL);
+ g_free((yyvsp[(3) - (3)].id));
}
break;
case 107:
-#line 1546 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1567 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-1].id), " ", (yyvsp[0].id), NULL);
- g_free((yyvsp[-1].id));
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat((yyvsp[(1) - (3)].id), " ",
+ (yyvsp[(2) - (3)].id), " const", NULL);
+ g_free((yyvsp[(2) - (3)].id));
}
break;
case 108:
-#line 1551 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1575 "parse.y"
{
- (yyval.id) = g_strconcat("const ", (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " ", (yyvsp[(2) - (2)].id), NULL);
+ g_free((yyvsp[(2) - (2)].id));
}
break;
case 109:
-#line 1555 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1579 "parse.y"
{
- (yyval.id) = (yyvsp[0].id);
+ (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " ", (yyvsp[(2) - (2)].id), NULL);
+ g_free((yyvsp[(1) - (2)].id));
+ g_free((yyvsp[(2) - (2)].id));
}
break;
case 110:
-#line 1558 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1584 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-1].id), " const", NULL);
- g_free((yyvsp[-1].id));
+ (yyval.id) = g_strconcat("const ", (yyvsp[(2) - (2)].id), NULL);
+ g_free((yyvsp[(2) - (2)].id));
}
break;
case 111:
-#line 1562 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1588 "parse.y"
{
- (yyval.id) = g_strdup((yyvsp[0].id));
+ (yyval.id) = (yyvsp[(1) - (1)].id);
}
break;
case 112:
-#line 1565 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1591 "parse.y"
{
- (yyval.id) = g_strconcat((yyvsp[-1].id), " const", NULL);
+ (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " const", NULL);
+ g_free((yyvsp[(1) - (2)].id));
}
break;
case 113:
-#line 1570 "parse.y"
- { (yyval.id) = "void"; }
+
+/* Line 1464 of yacc.c */
+#line 1595 "parse.y"
+ {
+ (yyval.id) = g_strdup((yyvsp[(1) - (1)].id));
+ }
break;
case 114:
-#line 1571 "parse.y"
- { (yyval.id) = "char"; }
+
+/* Line 1464 of yacc.c */
+#line 1598 "parse.y"
+ {
+ (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " const", NULL);
+ }
break;
case 115:
-#line 1572 "parse.y"
- { (yyval.id) = "short"; }
+
+/* Line 1464 of yacc.c */
+#line 1603 "parse.y"
+ { (yyval.id) = "void"; }
break;
case 116:
-#line 1573 "parse.y"
- { (yyval.id) = "int"; }
+
+/* Line 1464 of yacc.c */
+#line 1604 "parse.y"
+ { (yyval.id) = "char"; }
break;
case 117:
-#line 1574 "parse.y"
- { (yyval.id) = "long"; }
+
+/* Line 1464 of yacc.c */
+#line 1605 "parse.y"
+ { (yyval.id) = "short"; }
break;
case 118:
-#line 1575 "parse.y"
- { (yyval.id) = "float"; }
+
+/* Line 1464 of yacc.c */
+#line 1606 "parse.y"
+ { (yyval.id) = "int"; }
break;
case 119:
-#line 1576 "parse.y"
- { (yyval.id) = "double"; }
+
+/* Line 1464 of yacc.c */
+#line 1607 "parse.y"
+ { (yyval.id) = "long"; }
break;
case 120:
-#line 1577 "parse.y"
- { (yyval.id) = "signed"; }
+
+/* Line 1464 of yacc.c */
+#line 1608 "parse.y"
+ { (yyval.id) = "float"; }
break;
case 121:
-#line 1578 "parse.y"
- { (yyval.id) = "unsigned"; }
+
+/* Line 1464 of yacc.c */
+#line 1609 "parse.y"
+ { (yyval.id) = "double"; }
break;
case 122:
-#line 1581 "parse.y"
- { (yyval.id) = "struct"; }
+
+/* Line 1464 of yacc.c */
+#line 1610 "parse.y"
+ { (yyval.id) = "signed"; }
break;
case 123:
-#line 1582 "parse.y"
- { (yyval.id) = "union"; }
+
+/* Line 1464 of yacc.c */
+#line 1611 "parse.y"
+ { (yyval.id) = "unsigned"; }
break;
case 124:
-#line 1583 "parse.y"
- { (yyval.id) = "enum"; }
+
+/* Line 1464 of yacc.c */
+#line 1614 "parse.y"
+ { (yyval.id) = "struct"; }
break;
case 125:
-#line 1586 "parse.y"
- { (yyval.id) = g_strdup("*"); }
+
+/* Line 1464 of yacc.c */
+#line 1615 "parse.y"
+ { (yyval.id) = "union"; }
break;
case 126:
-#line 1587 "parse.y"
- { (yyval.id) = g_strdup("* const"); }
+
+/* Line 1464 of yacc.c */
+#line 1616 "parse.y"
+ { (yyval.id) = "enum"; }
break;
case 127:
-#line 1588 "parse.y"
+
+/* Line 1464 of yacc.c */
+#line 1619 "parse.y"
+ { (yyval.id) = g_strdup("*"); }
+ break;
+
+ case 128:
+
+/* Line 1464 of yacc.c */
+#line 1620 "parse.y"
+ { (yyval.id) = g_strdup("* const"); }
+ break;
+
+ case 129:
+
+/* Line 1464 of yacc.c */
+#line 1621 "parse.y"
{
- (yyval.id) = g_strconcat("*", (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat("*", (yyvsp[(2) - (2)].id), NULL);
+ g_free((yyvsp[(2) - (2)].id));
}
break;
- case 128:
-#line 1592 "parse.y"
+ case 130:
+
+/* Line 1464 of yacc.c */
+#line 1625 "parse.y"
{
- (yyval.id) = g_strconcat("* const", (yyvsp[0].id), NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat("* const", (yyvsp[(3) - (3)].id), NULL);
+ g_free((yyvsp[(3) - (3)].id));
}
break;
- case 129:
-#line 1599 "parse.y"
+ case 131:
+
+/* Line 1464 of yacc.c */
+#line 1632 "parse.y"
{
- if(strcmp((yyvsp[-1].id), "first")==0)
+ if(strcmp((yyvsp[(1) - (2)].id), "first")==0)
(yyval.sigtype) = SIGNAL_FIRST_METHOD;
- else if(strcmp((yyvsp[-1].id), "last")==0)
+ else if(strcmp((yyvsp[(1) - (2)].id), "last")==0)
(yyval.sigtype) = SIGNAL_LAST_METHOD;
else {
yyerror(_("signal must be 'first' or 'last'"));
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(1) - (2)].id));
YYERROR;
}
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(1) - (2)].id));
}
break;
- case 130:
-#line 1611 "parse.y"
+ case 132:
+
+/* Line 1464 of yacc.c */
+#line 1644 "parse.y"
{
(yyval.sigtype) = SIGNAL_LAST_METHOD;
}
break;
- case 131:
-#line 1617 "parse.y"
+ case 133:
+
+/* Line 1464 of yacc.c */
+#line 1650 "parse.y"
{
- if(strcmp((yyvsp[-1].id),"first")==0)
+ if(strcmp((yyvsp[(2) - (3)].id),"first")==0)
(yyval.sigtype) = SIGNAL_FIRST_METHOD;
- else if(strcmp((yyvsp[-1].id),"last")==0)
+ else if(strcmp((yyvsp[(2) - (3)].id),"last")==0)
(yyval.sigtype) = SIGNAL_LAST_METHOD;
else {
yyerror(_("signal must be 'first' or 'last'"));
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(2) - (3)].id));
YYERROR;
}
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(2) - (3)].id));
}
break;
- case 132:
-#line 1629 "parse.y"
+ case 134:
+
+/* Line 1464 of yacc.c */
+#line 1662 "parse.y"
{
- if(strcmp((yyvsp[-2].id),"first")==0)
+ if(strcmp((yyvsp[(1) - (3)].id),"first")==0)
(yyval.sigtype) = SIGNAL_FIRST_METHOD;
- else if(strcmp((yyvsp[-2].id),"last")==0)
+ else if(strcmp((yyvsp[(1) - (3)].id),"last")==0)
(yyval.sigtype) = SIGNAL_LAST_METHOD;
else {
yyerror(_("signal must be 'first' or 'last'"));
- g_free((yyvsp[-2].id));
+ g_free((yyvsp[(1) - (3)].id));
YYERROR;
}
- g_free((yyvsp[-2].id));
+ g_free((yyvsp[(1) - (3)].id));
}
break;
- case 133:
-#line 1641 "parse.y"
+ case 135:
+
+/* Line 1464 of yacc.c */
+#line 1674 "parse.y"
{
(yyval.sigtype) = SIGNAL_LAST_METHOD;
}
break;
- case 134:
-#line 1644 "parse.y"
+ case 136:
+
+/* Line 1464 of yacc.c */
+#line 1677 "parse.y"
{
/* the_scope was default thus public */
the_scope = PUBLIC_SCOPE;
}
break;
- case 135:
-#line 1650 "parse.y"
+ case 137:
+
+/* Line 1464 of yacc.c */
+#line 1683 "parse.y"
{
- gtktypes = g_list_prepend(gtktypes, debool ((yyvsp[-3].id)));
+ gtktypes = g_list_prepend(gtktypes, debool ((yyvsp[(1) - (4)].id)));
}
break;
- case 136:
-#line 1655 "parse.y"
+ case 138:
+
+/* Line 1464 of yacc.c */
+#line 1688 "parse.y"
{
- gtktypes = g_list_append(gtktypes, debool ((yyvsp[0].id)));
+ gtktypes = g_list_append(gtktypes, debool ((yyvsp[(3) - (3)].id)));
}
break;
- case 137:
-#line 1658 "parse.y"
+ case 139:
+
+/* Line 1464 of yacc.c */
+#line 1691 "parse.y"
{
- gtktypes = g_list_append(gtktypes, debool ((yyvsp[0].id)));
+ gtktypes = g_list_append(gtktypes, debool ((yyvsp[(1) - (1)].id)));
}
break;
- case 138:
-#line 1663 "parse.y"
- { (yyval.cbuf) = (yyvsp[0].cbuf); }
+ case 140:
+
+/* Line 1464 of yacc.c */
+#line 1696 "parse.y"
+ { (yyval.cbuf) = (yyvsp[(2) - (2)].cbuf); }
break;
- case 139:
-#line 1664 "parse.y"
+ case 141:
+
+/* Line 1464 of yacc.c */
+#line 1697 "parse.y"
{ (yyval.cbuf) = NULL; }
break;
- case 140:
-#line 1668 "parse.y"
+ case 142:
+
+/* Line 1464 of yacc.c */
+#line 1701 "parse.y"
{
if(!has_self) {
yyerror(_("signal without 'self' as "
free_all_global_state();
YYERROR;
}
- push_function(the_scope, (yyvsp[-7].sigtype),NULL,
- (yyvsp[-5].id), (yyvsp[0].cbuf),(yyvsp[-9].line),
- ccode_line, vararg, (yyvsp[-8].list));
+ if (funcattrs != NULL) {
+ char *error = g_strdup_printf
+ (_("function attribute macros ('%s' in this case) may not be used with signal methods"),
+ funcattrs);
+ yyerror (error);
+ YYERROR;
+ }
+ push_function(the_scope, (yyvsp[(3) - (10)].sigtype),NULL,
+ (yyvsp[(5) - (10)].id), (yyvsp[(10) - (10)].cbuf),(yyvsp[(1) - (10)].line),
+ ccode_line, vararg, (yyvsp[(2) - (10)].list));
}
break;
- case 141:
-#line 1684 "parse.y"
+ case 143:
+
+/* Line 1464 of yacc.c */
+#line 1724 "parse.y"
{
if(!has_self) {
yyerror(_("signal without 'self' as "
free_all_global_state();
YYERROR;
}
- push_function(the_scope, (yyvsp[-7].sigtype), NULL,
- (yyvsp[-5].id), (yyvsp[0].cbuf), (yyvsp[-9].line),
- ccode_line, vararg, (yyvsp[-8].list));
+ if (funcattrs != NULL) {
+ char *error = g_strdup_printf
+ (_("function attribute macros ('%s' in this case) may not be used with signal methods"),
+ funcattrs);
+ yyerror (error);
+ YYERROR;
+ }
+ push_function(the_scope, (yyvsp[(4) - (11)].sigtype), NULL,
+ (yyvsp[(6) - (11)].id), (yyvsp[(11) - (11)].cbuf), (yyvsp[(2) - (11)].line),
+ ccode_line, vararg, (yyvsp[(3) - (11)].list));
}
break;
- case 142:
-#line 1700 "parse.y"
+ case 144:
+
+/* Line 1464 of yacc.c */
+#line 1747 "parse.y"
{
if(!has_self) {
yyerror(_("virtual method without 'self' as "
free_all_global_state();
YYERROR;
}
- push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[-5].id),
- (yyvsp[0].cbuf), (yyvsp[-8].line),
+ if (funcattrs != NULL) {
+ char *error = g_strdup_printf
+ (_("function attribute macros ('%s' in this case) may not be used with virtual methods"),
+ funcattrs);
+ yyerror (error);
+ YYERROR;
+ }
+ push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[(4) - (9)].id),
+ (yyvsp[(9) - (9)].cbuf), (yyvsp[(1) - (9)].line),
ccode_line, vararg, NULL);
}
break;
- case 143:
-#line 1716 "parse.y"
+ case 145:
+
+/* Line 1464 of yacc.c */
+#line 1770 "parse.y"
{
if(!has_self) {
yyerror(_("virtual method without 'self' as "
free_all_global_state();
YYERROR;
}
- push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[-5].id),
- (yyvsp[0].cbuf), (yyvsp[-7].line),
+ if (funcattrs != NULL) {
+ char *error = g_strdup_printf
+ (_("function attribute macros ('%s' in this case) may not be used with virtual methods"),
+ funcattrs);
+ yyerror (error);
+ YYERROR;
+ }
+ push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[(4) - (9)].id),
+ (yyvsp[(9) - (9)].cbuf), (yyvsp[(2) - (9)].line),
ccode_line, vararg, NULL);
}
break;
- case 144:
-#line 1732 "parse.y"
+ case 146:
+
+/* Line 1464 of yacc.c */
+#line 1793 "parse.y"
{
if(!has_self) {
- yyerror(_("virtual method without 'self' as "
+ yyerror(_("virtual method without 'szelf' as "
"first parameter"));
free_all_global_state();
YYERROR;
}
+ if (funcattrs != NULL) {
+ char *error = g_strdup_printf
+ (_("function attribute macros ('%s' in this case) may not be used with virtual methods"),
+ funcattrs);
+ yyerror (error);
+ YYERROR;
+ }
push_function(PUBLIC_SCOPE, VIRTUAL_METHOD, NULL,
- (yyvsp[-5].id), (yyvsp[0].cbuf), (yyvsp[-7].line),
+ (yyvsp[(3) - (8)].id), (yyvsp[(8) - (8)].cbuf), (yyvsp[(1) - (8)].line),
ccode_line, vararg, NULL);
}
break;
- case 145:
-#line 1743 "parse.y"
- {
- push_function(NO_SCOPE, OVERRIDE_METHOD, (yyvsp[-8].id),
- (yyvsp[-5].id), (yyvsp[0].cbuf),
- (yyvsp[-10].line), ccode_line,
+ case 147:
+
+/* Line 1464 of yacc.c */
+#line 1811 "parse.y"
+ {
+ if (funcattrs != NULL) {
+ char *error = g_strdup_printf
+ (_("function attribute macros ('%s' in this case) may not be used with override methods"),
+ funcattrs);
+ yyerror (error);
+ YYERROR;
+ }
+ push_function(NO_SCOPE, OVERRIDE_METHOD, (yyvsp[(3) - (11)].id),
+ (yyvsp[(6) - (11)].id), (yyvsp[(11) - (11)].cbuf),
+ (yyvsp[(1) - (11)].line), ccode_line,
vararg, NULL);
}
break;
- case 146:
-#line 1749 "parse.y"
+ case 148:
+
+/* Line 1464 of yacc.c */
+#line 1824 "parse.y"
{
if(the_scope == CLASS_SCOPE) {
yyerror(_("a method cannot be of class scope"));
free_all_global_state();
YYERROR;
}
- push_function(the_scope, REGULAR_METHOD, NULL, (yyvsp[-5].id),
- (yyvsp[0].cbuf), (yyvsp[-7].line), ccode_line,
+ push_function(the_scope, REGULAR_METHOD, NULL, (yyvsp[(3) - (8)].id),
+ (yyvsp[(8) - (8)].cbuf), (yyvsp[(1) - (8)].line), ccode_line,
vararg, NULL);
}
break;
- case 147:
-#line 1759 "parse.y"
+ case 149:
+
+/* Line 1464 of yacc.c */
+#line 1834 "parse.y"
{
- if(strcmp((yyvsp[-4].id), "init")==0) {
- push_init_arg((yyvsp[-2].id),FALSE);
+ if(strcmp((yyvsp[(1) - (5)].id), "init")==0) {
+ push_init_arg((yyvsp[(3) - (5)].id),FALSE);
push_function(NO_SCOPE, INIT_METHOD, NULL,
- (yyvsp[-4].id), (yyvsp[0].cbuf), (yyvsp[-3].line),
+ (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
ccode_line, FALSE, NULL);
- } else if(strcmp((yyvsp[-4].id), "class_init")==0) {
- push_init_arg((yyvsp[-2].id),TRUE);
+ } else if(strcmp((yyvsp[(1) - (5)].id), "class_init")==0) {
+ push_init_arg((yyvsp[(3) - (5)].id),TRUE);
push_function(NO_SCOPE, CLASS_INIT_METHOD, NULL,
- (yyvsp[-4].id), (yyvsp[0].cbuf), (yyvsp[-3].line),
+ (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
+ ccode_line, FALSE, NULL);
+ } else if(strcmp((yyvsp[(1) - (5)].id), "constructor")==0) {
+ push_init_arg((yyvsp[(3) - (5)].id), FALSE);
+ push_function(NO_SCOPE, CONSTRUCTOR_METHOD, NULL,
+ (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
+ ccode_line, FALSE, NULL);
+ } else if(strcmp((yyvsp[(1) - (5)].id), "dispose")==0) {
+ push_init_arg((yyvsp[(3) - (5)].id), FALSE);
+ push_function(NO_SCOPE, DISPOSE_METHOD, NULL,
+ (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
+ ccode_line, FALSE, NULL);
+ } else if(strcmp((yyvsp[(1) - (5)].id), "finalize")==0) {
+ push_init_arg((yyvsp[(3) - (5)].id), FALSE);
+ push_function(NO_SCOPE, FINALIZE_METHOD, NULL,
+ (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
ccode_line, FALSE, NULL);
+
} else {
- g_free((yyvsp[-4].id));
- g_free((yyvsp[-2].id));
- g_string_free((yyvsp[0].cbuf),TRUE);
+ g_free((yyvsp[(1) - (5)].id));
+ g_free((yyvsp[(3) - (5)].id));
+ g_string_free((yyvsp[(5) - (5)].cbuf),TRUE);
yyerror(_("parse error "
- "(untyped blocks must be init or "
- "class_init)"));
+ "(untyped blocks must be init, "
+ "class_init, constructor, dispose "
+ "or finalize)"));
YYERROR;
}
}
break;
- case 148:
-#line 1782 "parse.y"
+ case 150:
+
+/* Line 1464 of yacc.c */
+#line 1874 "parse.y"
{
+ g_free(funcattrs); funcattrs = NULL;
g_free(onerror); onerror = NULL;
g_free(defreturn); defreturn = NULL;
- if(!set_return_value((yyvsp[-1].id), (yyvsp[0].id))) {
- g_free((yyvsp[-1].id));
- g_free((yyvsp[0].id));
+ if(!set_attr_value((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id))) {
+ g_free((yyvsp[(1) - (2)].id));
+ g_free((yyvsp[(2) - (2)].id));
yyerror(_("parse error"));
YYERROR;
}
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(1) - (2)].id));
}
break;
- case 149:
-#line 1793 "parse.y"
+ case 151:
+
+/* Line 1464 of yacc.c */
+#line 1886 "parse.y"
{
+ g_free(funcattrs); funcattrs = NULL;
g_free(onerror); onerror = NULL;
g_free(defreturn); defreturn = NULL;
- if(!set_return_value((yyvsp[-3].id), (yyvsp[-2].id))) {
- g_free((yyvsp[-3].id)); g_free((yyvsp[-2].id));
- g_free((yyvsp[-1].id)); g_free((yyvsp[0].id));
+ if(!set_attr_value((yyvsp[(1) - (4)].id), (yyvsp[(2) - (4)].id))) {
+ g_free((yyvsp[(1) - (4)].id)); g_free((yyvsp[(2) - (4)].id));
+ g_free((yyvsp[(3) - (4)].id)); g_free((yyvsp[(4) - (4)].id));
yyerror(_("parse error"));
YYERROR;
}
- if(!set_return_value((yyvsp[-1].id), (yyvsp[0].id))) {
- onerror = defreturn = NULL;
- g_free((yyvsp[-3].id)); g_free((yyvsp[-2].id));
- g_free((yyvsp[-1].id)); g_free((yyvsp[0].id));
+ if(!set_attr_value((yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id))) {
+ funcattrs = onerror = defreturn = NULL;
+ g_free((yyvsp[(1) - (4)].id)); g_free((yyvsp[(2) - (4)].id));
+ g_free((yyvsp[(3) - (4)].id)); g_free((yyvsp[(4) - (4)].id));
yyerror(_("parse error"));
YYERROR;
}
- g_free((yyvsp[-3].id));
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(1) - (4)].id));
+ g_free((yyvsp[(3) - (4)].id));
}
break;
- case 150:
-#line 1812 "parse.y"
+ case 152:
+
+/* Line 1464 of yacc.c */
+#line 1906 "parse.y"
+ {
+ g_free(funcattrs); funcattrs = NULL;
+ g_free(onerror); onerror = NULL;
+ g_free(defreturn); defreturn = NULL;
+ if(!set_attr_value((yyvsp[(1) - (6)].id), (yyvsp[(2) - (6)].id))) {
+ g_free((yyvsp[(1) - (6)].id)); g_free((yyvsp[(2) - (6)].id));
+ g_free((yyvsp[(3) - (6)].id)); g_free((yyvsp[(4) - (6)].id));
+ g_free((yyvsp[(5) - (6)].id)); g_free((yyvsp[(6) - (6)].id));
+ yyerror(_("parse error"));
+ YYERROR;
+ }
+ if(!set_attr_value((yyvsp[(3) - (6)].id), (yyvsp[(4) - (6)].id))) {
+ funcattrs = onerror = defreturn = NULL;
+ g_free((yyvsp[(1) - (6)].id)); g_free((yyvsp[(2) - (6)].id));
+ g_free((yyvsp[(3) - (6)].id)); g_free((yyvsp[(4) - (6)].id));
+ g_free((yyvsp[(5) - (6)].id)); g_free((yyvsp[(6) - (6)].id));
+ yyerror(_("parse error"));
+ YYERROR;
+ }
+ if(!set_attr_value((yyvsp[(5) - (6)].id), (yyvsp[(6) - (6)].id))) {
+ funcattrs = onerror = defreturn = NULL;
+ g_free((yyvsp[(1) - (6)].id)); g_free((yyvsp[(2) - (6)].id));
+ g_free((yyvsp[(3) - (6)].id)); g_free((yyvsp[(4) - (6)].id));
+ g_free((yyvsp[(5) - (6)].id)); g_free((yyvsp[(6) - (6)].id));
+ yyerror(_("parse error"));
+ YYERROR;
+ }
+ g_free((yyvsp[(1) - (6)].id));
+ g_free((yyvsp[(3) - (6)].id));
+ g_free((yyvsp[(5) - (6)].id));
+ }
+ break;
+
+ case 153:
+
+/* Line 1464 of yacc.c */
+#line 1937 "parse.y"
{
+ g_free(funcattrs); funcattrs = NULL;
g_free(onerror); onerror = NULL;
g_free(defreturn); defreturn = NULL;
}
break;
- case 151:
-#line 1818 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
+ case 154:
+
+/* Line 1464 of yacc.c */
+#line 1944 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
break;
- case 152:
-#line 1819 "parse.y"
+ case 155:
+
+/* Line 1464 of yacc.c */
+#line 1945 "parse.y"
{
- (yyval.id) = ((yyvsp[0].cbuf))->str;
- g_string_free((yyvsp[0].cbuf), FALSE);
+ (yyval.id) = ((yyvsp[(2) - (2)].cbuf))->str;
+ g_string_free((yyvsp[(2) - (2)].cbuf), FALSE);
}
break;
- case 153:
-#line 1825 "parse.y"
+ case 156:
+
+/* Line 1464 of yacc.c */
+#line 1951 "parse.y"
{ vararg = FALSE; has_self = FALSE; }
break;
- case 154:
-#line 1826 "parse.y"
+ case 157:
+
+/* Line 1464 of yacc.c */
+#line 1952 "parse.y"
{
vararg = FALSE;
has_self = TRUE;
- if(strcmp((yyvsp[0].id),"self")==0)
- push_self((yyvsp[0].id), FALSE);
+ if(strcmp((yyvsp[(1) - (1)].id),"self")==0)
+ push_self((yyvsp[(1) - (1)].id), FALSE);
else {
- g_free((yyvsp[0].id));
+ g_free((yyvsp[(1) - (1)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 155:
-#line 1837 "parse.y"
+ case 158:
+
+/* Line 1464 of yacc.c */
+#line 1963 "parse.y"
{
vararg = FALSE;
has_self = TRUE;
- if(strcmp((yyvsp[-1].id),"self")==0)
- push_self((yyvsp[-1].id), TRUE);
+ if(strcmp((yyvsp[(1) - (2)].id),"self")==0)
+ push_self((yyvsp[(1) - (2)].id), TRUE);
else {
- g_free((yyvsp[-1].id));
+ g_free((yyvsp[(1) - (2)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 156:
-#line 1848 "parse.y"
+ case 159:
+
+/* Line 1464 of yacc.c */
+#line 1974 "parse.y"
{
vararg = FALSE;
has_self = TRUE;
- if(strcmp((yyvsp[0].id),"self")==0)
- push_self((yyvsp[0].id), TRUE);
+ if(strcmp((yyvsp[(2) - (2)].id),"self")==0)
+ push_self((yyvsp[(2) - (2)].id), TRUE);
else {
- g_free((yyvsp[0].id));
+ g_free((yyvsp[(2) - (2)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 157:
-#line 1859 "parse.y"
+ case 160:
+
+/* Line 1464 of yacc.c */
+#line 1985 "parse.y"
{
has_self = TRUE;
- if(strcmp((yyvsp[-2].id),"self")==0)
- push_self((yyvsp[-2].id), FALSE);
+ if(strcmp((yyvsp[(1) - (3)].id),"self")==0)
+ push_self((yyvsp[(1) - (3)].id), FALSE);
else {
- g_free((yyvsp[-2].id));
+ g_free((yyvsp[(1) - (3)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 158:
-#line 1869 "parse.y"
+ case 161:
+
+/* Line 1464 of yacc.c */
+#line 1995 "parse.y"
{
has_self = TRUE;
- if(strcmp((yyvsp[-3].id),"self")==0)
- push_self((yyvsp[-3].id), TRUE);
+ if(strcmp((yyvsp[(1) - (4)].id),"self")==0)
+ push_self((yyvsp[(1) - (4)].id), TRUE);
else {
- g_free((yyvsp[-3].id));
+ g_free((yyvsp[(1) - (4)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 159:
-#line 1879 "parse.y"
+ case 162:
+
+/* Line 1464 of yacc.c */
+#line 2005 "parse.y"
{
has_self = TRUE;
- if(strcmp((yyvsp[-2].id),"self")==0)
- push_self((yyvsp[-2].id), TRUE);
+ if(strcmp((yyvsp[(2) - (4)].id),"self")==0)
+ push_self((yyvsp[(2) - (4)].id), TRUE);
else {
- g_free((yyvsp[-2].id));
+ g_free((yyvsp[(2) - (4)].id));
yyerror(_("parse error"));
YYERROR;
}
}
break;
- case 160:
-#line 1889 "parse.y"
+ case 163:
+
+/* Line 1464 of yacc.c */
+#line 2015 "parse.y"
{ has_self = FALSE; }
break;
- case 161:
-#line 1892 "parse.y"
+ case 164:
+
+/* Line 1464 of yacc.c */
+#line 2018 "parse.y"
{ vararg = TRUE; }
break;
- case 162:
-#line 1893 "parse.y"
+ case 165:
+
+/* Line 1464 of yacc.c */
+#line 2019 "parse.y"
{ vararg = FALSE; }
break;
- case 163:
-#line 1896 "parse.y"
+ case 166:
+
+/* Line 1464 of yacc.c */
+#line 2022 "parse.y"
{ ; }
break;
- case 164:
-#line 1897 "parse.y"
+ case 167:
+
+/* Line 1464 of yacc.c */
+#line 2023 "parse.y"
{ ; }
break;
- case 165:
-#line 1900 "parse.y"
+ case 168:
+
+/* Line 1464 of yacc.c */
+#line 2026 "parse.y"
{
- push_funcarg((yyvsp[0].id),NULL);
+ push_funcarg((yyvsp[(2) - (2)].id),NULL);
}
break;
- case 166:
-#line 1903 "parse.y"
+ case 169:
+
+/* Line 1464 of yacc.c */
+#line 2029 "parse.y"
{
- push_funcarg((yyvsp[-1].id),(yyvsp[0].id));
+ push_funcarg((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].id));
}
break;
- case 167:
-#line 1906 "parse.y"
+ case 170:
+
+/* Line 1464 of yacc.c */
+#line 2032 "parse.y"
{
- if(strcmp((yyvsp[-2].id),"check")!=0) {
+ if(strcmp((yyvsp[(4) - (6)].id),"check")!=0) {
yyerror(_("parse error"));
YYERROR;
}
- g_free((yyvsp[-2].id));
- push_funcarg((yyvsp[-4].id),NULL);
+ g_free((yyvsp[(4) - (6)].id));
+ push_funcarg((yyvsp[(2) - (6)].id),NULL);
}
break;
- case 168:
-#line 1914 "parse.y"
+ case 171:
+
+/* Line 1464 of yacc.c */
+#line 2040 "parse.y"
{
- if(strcmp((yyvsp[-2].id),"check")!=0) {
+ if(strcmp((yyvsp[(5) - (7)].id),"check")!=0) {
yyerror(_("parse error"));
YYERROR;
}
- g_free((yyvsp[-2].id));
- push_funcarg((yyvsp[-5].id),(yyvsp[-4].id));
+ g_free((yyvsp[(5) - (7)].id));
+ push_funcarg((yyvsp[(2) - (7)].id),(yyvsp[(3) - (7)].id));
}
break;
- case 169:
-#line 1924 "parse.y"
+ case 172:
+
+/* Line 1464 of yacc.c */
+#line 2050 "parse.y"
{ ; }
break;
- case 170:
-#line 1925 "parse.y"
+ case 173:
+
+/* Line 1464 of yacc.c */
+#line 2051 "parse.y"
{ ; }
break;
- case 171:
-#line 1928 "parse.y"
+ case 174:
+
+/* Line 1464 of yacc.c */
+#line 2054 "parse.y"
{
- if(strcmp((yyvsp[0].id),"type")==0) {
+ if(strcmp((yyvsp[(1) - (1)].id),"type")==0) {
Node *node = node_new (CHECK_NODE,
"chtype", TYPE_CHECK,
NULL);
checks = g_list_append(checks,node);
- } else if(strcmp((yyvsp[0].id),"null")==0) {
+ } else if(strcmp((yyvsp[(1) - (1)].id),"null")==0) {
Node *node = node_new (CHECK_NODE,
"chtype", NULL_CHECK,
NULL);
yyerror(_("parse error"));
YYERROR;
}
- g_free((yyvsp[0].id));
+ g_free((yyvsp[(1) - (1)].id));
}
break;
- case 172:
-#line 1945 "parse.y"
+ case 175:
+
+/* Line 1464 of yacc.c */
+#line 2071 "parse.y"
{
Node *node = node_new (CHECK_NODE,
"chtype", GT_CHECK,
- "number:steal", (yyvsp[0].id),
+ "number:steal", (yyvsp[(2) - (2)].id),
NULL);
checks = g_list_append(checks,node);
}
break;
- case 173:
-#line 1952 "parse.y"
+ case 176:
+
+/* Line 1464 of yacc.c */
+#line 2078 "parse.y"
{
Node *node = node_new (CHECK_NODE,
"chtype", LT_CHECK,
- "number:steal", (yyvsp[0].id),
+ "number:steal", (yyvsp[(2) - (2)].id),
NULL);
checks = g_list_append(checks,node);
}
break;
- case 174:
-#line 1959 "parse.y"
+ case 177:
+
+/* Line 1464 of yacc.c */
+#line 2085 "parse.y"
{
Node *node = node_new (CHECK_NODE,
"chtype", GE_CHECK,
- "number:steal", (yyvsp[0].id),
+ "number:steal", (yyvsp[(3) - (3)].id),
NULL);
checks = g_list_append(checks,node);
}
break;
- case 175:
-#line 1966 "parse.y"
+ case 178:
+
+/* Line 1464 of yacc.c */
+#line 2092 "parse.y"
{
Node *node = node_new (CHECK_NODE,
"chtype", LE_CHECK,
- "number:steal", (yyvsp[0].id),
+ "number:steal", (yyvsp[(3) - (3)].id),
NULL);
checks = g_list_append(checks,node);
}
break;
- case 176:
-#line 1973 "parse.y"
+ case 179:
+
+/* Line 1464 of yacc.c */
+#line 2099 "parse.y"
{
Node *node = node_new (CHECK_NODE,
"chtype", EQ_CHECK,
- "number:steal", (yyvsp[0].id),
+ "number:steal", (yyvsp[(3) - (3)].id),
NULL);
checks = g_list_append(checks,node);
}
break;
- case 177:
-#line 1980 "parse.y"
+ case 180:
+
+/* Line 1464 of yacc.c */
+#line 2106 "parse.y"
{
Node *node = node_new (CHECK_NODE,
"chtype", NE_CHECK,
- "number:steal", (yyvsp[0].id),
+ "number:steal", (yyvsp[(3) - (3)].id),
NULL);
checks = g_list_append(checks,node);
}
break;
- case 178:
-#line 1989 "parse.y"
+ case 181:
+
+/* Line 1464 of yacc.c */
+#line 2115 "parse.y"
{
Node *node = node_new (ENUMDEF_NODE,
- "etype:steal", (yyvsp[-1].id),
- "prefix:steal", (yyvsp[-5].id),
+ "etype:steal", (yyvsp[(6) - (7)].id),
+ "prefix:steal", (yyvsp[(2) - (7)].id),
"values:steal", enum_vals,
NULL);
enum_vals = NULL;
}
break;
- case 179:
-#line 1998 "parse.y"
+ case 182:
+
+/* Line 1464 of yacc.c */
+#line 2124 "parse.y"
{
Node *node = node_new (ENUMDEF_NODE,
- "etype:steal", (yyvsp[-1].id),
- "prefix:steal", (yyvsp[-6].id),
+ "etype:steal", (yyvsp[(7) - (8)].id),
+ "prefix:steal", (yyvsp[(2) - (8)].id),
"values:steal", enum_vals,
NULL);
enum_vals = NULL;
}
break;
- case 180:
-#line 2009 "parse.y"
+ case 183:
+
+/* Line 1464 of yacc.c */
+#line 2135 "parse.y"
{;}
break;
- case 181:
-#line 2010 "parse.y"
+ case 184:
+
+/* Line 1464 of yacc.c */
+#line 2136 "parse.y"
{;}
break;
- case 182:
-#line 2013 "parse.y"
+ case 185:
+
+/* Line 1464 of yacc.c */
+#line 2139 "parse.y"
{
Node *node;
- char *num = (yyvsp[0].id);
+ char *num = (yyvsp[(3) - (3)].id);
/* A float value, that's a bad enum */
if (num[0] >= '0' &&
num[0] <= '9' &&
strchr (num, '.') != NULL) {
- g_free ((yyvsp[-2].id));
+ g_free ((yyvsp[(1) - (3)].id));
g_free (num);
yyerror(_("parse error (enumerator value not integer constant)"));
YYERROR;
}
node = node_new (ENUMVALUE_NODE,
- "name:steal", (yyvsp[-2].id),
+ "name:steal", (yyvsp[(1) - (3)].id),
"value:steal", num,
NULL);
enum_vals = g_list_append (enum_vals, node);
}
break;
- case 183:
-#line 2033 "parse.y"
+ case 186:
+
+/* Line 1464 of yacc.c */
+#line 2159 "parse.y"
{
Node *node;
node = node_new (ENUMVALUE_NODE,
- "name:steal", (yyvsp[0].id),
+ "name:steal", (yyvsp[(1) - (1)].id),
NULL);
enum_vals = g_list_append (enum_vals, node);
}
break;
- case 184:
-#line 2043 "parse.y"
+ case 187:
+
+/* Line 1464 of yacc.c */
+#line 2169 "parse.y"
{
Node *node = node_new (FLAGS_NODE,
- "ftype:steal", (yyvsp[-1].id),
- "prefix:steal", (yyvsp[-5].id),
+ "ftype:steal", (yyvsp[(6) - (7)].id),
+ "prefix:steal", (yyvsp[(2) - (7)].id),
"values:steal", flag_vals,
NULL);
flag_vals = NULL;
}
break;
- case 185:
-#line 2052 "parse.y"
+ case 188:
+
+/* Line 1464 of yacc.c */
+#line 2178 "parse.y"
{
Node *node = node_new (FLAGS_NODE,
- "ftype:steal", (yyvsp[-1].id),
- "prefix:steal", (yyvsp[-6].id),
+ "ftype:steal", (yyvsp[(7) - (8)].id),
+ "prefix:steal", (yyvsp[(2) - (8)].id),
"values:steal", flag_vals,
NULL);
flag_vals = NULL;
}
break;
- case 186:
-#line 2063 "parse.y"
+ case 189:
+
+/* Line 1464 of yacc.c */
+#line 2189 "parse.y"
{
- flag_vals = g_list_append (flag_vals, (yyvsp[0].id));
+ flag_vals = g_list_append (flag_vals, (yyvsp[(3) - (3)].id));
}
break;
- case 187:
-#line 2066 "parse.y"
+ case 190:
+
+/* Line 1464 of yacc.c */
+#line 2192 "parse.y"
{
- flag_vals = g_list_append (flag_vals, (yyvsp[0].id));
+ flag_vals = g_list_append (flag_vals, (yyvsp[(1) - (1)].id));
}
break;
- case 188:
-#line 2071 "parse.y"
+ case 191:
+
+/* Line 1464 of yacc.c */
+#line 2197 "parse.y"
{
Node *node = node_new (ERROR_NODE,
- "etype:steal", (yyvsp[-1].id),
- "prefix:steal", (yyvsp[-5].id),
+ "etype:steal", (yyvsp[(6) - (7)].id),
+ "prefix:steal", (yyvsp[(2) - (7)].id),
"values:steal", error_vals,
NULL);
error_vals = NULL;
}
break;
- case 189:
-#line 2080 "parse.y"
+ case 192:
+
+/* Line 1464 of yacc.c */
+#line 2206 "parse.y"
{
Node *node = node_new (ERROR_NODE,
- "etype:steal", (yyvsp[-1].id),
- "prefix:steal", (yyvsp[-6].id),
+ "etype:steal", (yyvsp[(7) - (8)].id),
+ "prefix:steal", (yyvsp[(2) - (8)].id),
"values:steal", error_vals,
NULL);
error_vals = NULL;
}
break;
- case 190:
-#line 2091 "parse.y"
+ case 193:
+
+/* Line 1464 of yacc.c */
+#line 2217 "parse.y"
{
- error_vals = g_list_append (error_vals, (yyvsp[0].id));
+ error_vals = g_list_append (error_vals, (yyvsp[(3) - (3)].id));
}
break;
- case 191:
-#line 2094 "parse.y"
+ case 194:
+
+/* Line 1464 of yacc.c */
+#line 2220 "parse.y"
{
- error_vals = g_list_append (error_vals, (yyvsp[0].id));
+ error_vals = g_list_append (error_vals, (yyvsp[(1) - (1)].id));
}
break;
- case 192:
-#line 2100 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
+ case 195:
+
+/* Line 1464 of yacc.c */
+#line 2226 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
break;
- case 193:
-#line 2101 "parse.y"
+ case 196:
+
+/* Line 1464 of yacc.c */
+#line 2227 "parse.y"
{
- (yyval.id) = g_strconcat("-",(yyvsp[0].id),NULL);
- g_free((yyvsp[0].id));
+ (yyval.id) = g_strconcat("-",(yyvsp[(2) - (2)].id),NULL);
+ g_free((yyvsp[(2) - (2)].id));
}
break;
- case 194:
-#line 2105 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
- break;
+ case 197:
- case 195:
-#line 2106 "parse.y"
- { (yyval.id) = (yyvsp[0].id); }
+/* Line 1464 of yacc.c */
+#line 2231 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
break;
+ case 198:
- }
+/* Line 1464 of yacc.c */
+#line 2232 "parse.y"
+ { (yyval.id) = (yyvsp[(1) - (1)].id); }
+ break;
-/* Line 1037 of yacc.c. */
-#line 4252 "y.tab.c"
-\f
- yyvsp -= yylen;
- yyssp -= yylen;
+/* Line 1464 of yacc.c */
+#line 5120 "parse.c"
+ default: break;
+ }
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++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. */
if (!yyerrstatus)
{
++yynerrs;
-#if YYERROR_VERBOSE
- yyn = yypact[yystate];
-
- if (YYPACT_NINF < yyn && yyn < YYLAST)
- {
- YYSIZE_T yysize = 0;
- int yytype = YYTRANSLATE (yychar);
- const char* yyprefix;
- char *yymsg;
- int yyx;
-
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
-
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- int yycount = 0;
-
- yyprefix = ", expecting ";
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+#if ! YYERROR_VERBOSE
+ yyerror (YY_("syntax error"));
+#else
+ {
+ YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+ if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+ {
+ YYSIZE_T yyalloc = 2 * yysize;
+ if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+ yyalloc = YYSTACK_ALLOC_MAXIMUM;
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+ if (yymsg)
+ yymsg_alloc = yyalloc;
+ else
{
- yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
- yycount += 1;
- if (yycount == 5)
- {
- yysize = 0;
- break;
- }
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
}
- yysize += (sizeof ("syntax error, unexpected ")
- + yystrlen (yytname[yytype]));
- yymsg = (char *) YYSTACK_ALLOC (yysize);
- if (yymsg != 0)
- {
- char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
- yyp = yystpcpy (yyp, yytname[yytype]);
+ }
- if (yycount < 5)
- {
- yyprefix = ", expecting ";
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
- {
- yyp = yystpcpy (yyp, yyprefix);
- yyp = yystpcpy (yyp, yytname[yyx]);
- yyprefix = " or ";
- }
- }
- yyerror (yymsg);
- YYSTACK_FREE (yymsg);
- }
- else
- yyerror ("syntax error; also virtual memory exhausted");
- }
- else
-#endif /* YYERROR_VERBOSE */
- yyerror ("syntax error");
+ if (0 < yysize && yysize <= yymsg_alloc)
+ {
+ (void) yysyntax_error (yymsg, yystate, yychar);
+ yyerror (yymsg);
+ }
+ else
+ {
+ yyerror (YY_("syntax error"));
+ if (yysize != 0)
+ goto yyexhaustedlab;
+ }
+ }
+#endif
}
if (yyerrstatus == 3)
{
- /* If just tried and failed to reuse look-ahead token after an
+ /* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
- {
- /* If at end of input, pop the error token,
- then the rest of the stack, then return failure. */
+ {
+ /* Return failure if at end of input. */
if (yychar == YYEOF)
- for (;;)
- {
-
- YYPOPSTACK;
- if (yyssp == yyss)
- YYABORT;
- yydestruct ("Error: popping",
- yystos[*yyssp], yyvsp);
- }
- }
+ YYABORT;
+ }
else
{
- yydestruct ("Error: discarding", yytoken, &yylval);
+ yydestruct ("Error: discarding",
+ yytoken, &yylval);
yychar = YYEMPTY;
}
}
- /* Else will try to reuse look-ahead token after shifting the error
+ /* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
`---------------------------------------------------*/
yyerrorlab:
-#ifdef __GNUC__
- /* Pacify GCC when the user code never invokes YYERROR and the label
- yyerrorlab therefore never appears in user code. */
- if (0)
+ /* Pacify compilers like GCC when the user code never invokes
+ YYERROR and the label yyerrorlab therefore never appears in user
+ code. */
+ if (/*CONSTCOND*/ 0)
goto yyerrorlab;
-#endif
-yyvsp -= yylen;
- yyssp -= yylen;
+ /* Do not reclaim the symbols of the rule which action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
YYABORT;
- yydestruct ("Error: popping", yystos[yystate], yyvsp);
- YYPOPSTACK;
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp);
+ YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
- if (yyn == YYFINAL)
- YYACCEPT;
-
*++yyvsp = yylval;
- /* Shift the error token. */
+ /* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
- yydestruct ("Error: discarding lookahead",
- yytoken, &yylval);
- yychar = YYEMPTY;
yyresult = 1;
goto yyreturn;
-#ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here. |
-`----------------------------------------------*/
-yyoverflowlab:
- yyerror ("parser stack overflow");
+#if !defined(yyoverflow) || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
yyreturn:
+ if (yychar != YYEMPTY)
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval);
+ /* Do not reclaim the symbols of the rule which action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ yystos[*yyssp], yyvsp);
+ YYPOPSTACK (1);
+ }
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
- return yyresult;
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ /* Make sure YYID is used. */
+ return YYID (yyresult);
}
-#line 2109 "parse.y"
+
+/* Line 1684 of yacc.c */
+#line 2235 "parse.y"