1 /* A Bison parser, made by GNU Bison 2.0. */
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
36 /* Identify Bison output. */
40 #define YYSKELETON_NAME "yacc.c"
45 /* Using locations. */
46 #define YYLSP_NEEDED 0
53 /* Put the tokens into the symbol table, so that GDB and other debuggers
115 #define THREEDOTS 265
126 #define TYPETOKEN 276
127 #define ARRAY_DIM 277
128 #define SINGLE_CHAR 278
138 #define PROTECTED 288
139 #define CLASSWIDE 289
149 #define DEFAULT_VALUE 299
153 #define FLAGS_TYPE 303
154 #define ENUM_TYPE 304
155 #define PARAM_TYPE 305
156 #define BOXED_TYPE 306
157 #define OBJECT_TYPE 307
162 /* Copy the first part of user declarations. */
172 #include "treefuncs.h"
176 /* FIXME: add gettext support */
181 static GList *class_nodes = NULL;
184 static GList *enum_vals = NULL;
185 static GList *flag_vals = NULL;
186 static GList *error_vals = NULL;
188 static gboolean abstract = FALSE;
189 static char *chunk_size = NULL;
190 static char *bonobo_object_class = NULL;
191 static int glade_xml = FALSE;
192 static GList *interfaces = NULL;
193 static GList *typestack = NULL;
194 static GList *funcargs = NULL;
195 static GList *checks = NULL;
196 static int has_self = FALSE;
197 static int vararg = FALSE;
198 static Method *last_added_method = NULL;
200 /* destructor and initializer for variables */
201 static gboolean destructor_unref = FALSE;
202 static char *destructor = NULL;
203 static int destructor_line = 0;
204 static gboolean destructor_simple = TRUE;
205 static char *initializer = NULL;
206 static int initializer_line = 0;
207 static int glade_widget = FALSE;
209 static char *onerror = NULL;
210 static char *defreturn = NULL;
212 static GList *gtktypes = NULL;
214 static Property *property = NULL;
216 /* this can be a global as we will only do one function at a time
218 static int the_scope = NO_SCOPE;
220 void free(void *ptr);
223 extern int ccode_line;
225 extern gboolean for_cpp;
235 if(strcmp(yytext,"\n")==0) {
236 out=g_strconcat("Error: ",str," before newline",NULL);
237 } else if(yytext[0]=='\0') {
238 out=g_strconcat("Error: ", str, " at end of input", NULL);
240 char *tmp = g_strdup(yytext);
241 while((p=strchr(tmp, '\n')))
244 out=g_strconcat("Error: ", str, " before '", tmp, "'", NULL);
248 fprintf(stderr, "%s:%d: %s\n", filename, line_no, out);
257 Type *type = typestack->data;
258 typestack = g_list_remove(typestack,typestack->data);
263 push_variable (char *name, int scope, int line_no, char *postfix)
266 Type *type = pop_type ();
268 type->postfix = postfix;
270 var = node_new (VARIABLE_NODE,
273 "glade_widget", glade_widget,
276 "destructor_unref", destructor_unref,
277 "destructor:steal", destructor,
278 "destructor_line", destructor_line,
279 "destructor_simple", destructor_simple,
280 "initializer:steal", initializer,
281 "initializer_line", initializer_line,
282 "initializer_simple", TRUE,
284 class_nodes = g_list_append(class_nodes, var);
285 glade_widget = FALSE;
289 push_function (int scope, int method, char *oid, char *id,
290 GString *cbuf, int line_no, int ccode_line,
291 gboolean vararg, GList *flags)
297 g_assert(scope != CLASS_SCOPE);
299 if(method == INIT_METHOD || method == CLASS_INIT_METHOD) {
300 type = (Type *)node_new (TYPE_NODE,
307 /* a complicated and ugly test to figure out if we have
308 the wrong number of types for a signal */
309 if((method == SIGNAL_FIRST_METHOD ||
310 method == SIGNAL_LAST_METHOD) &&
311 g_list_length(gtktypes) != g_list_length(funcargs) &&
312 !(g_list_length(funcargs) == 1 &&
313 g_list_length(gtktypes) == 2 &&
314 strcmp(gtktypes->next->data, "NONE")==0)) {
315 error_print(GOB_WARN, line_no,
316 _("The number of GTK arguments and "
317 "function arguments for a signal "
318 "don't seem to match"));
320 if(g_list_length(gtktypes) > 2) {
322 for(li = gtktypes->next; li; li = li->next) {
323 if(strcmp(li->data, "NONE")==0) {
324 error_print(GOB_ERROR, line_no,
325 _("NONE can only appear in an "
326 "argument list by itself"));
332 c_cbuf = p = cbuf->str;
333 while(p && *p && (*p==' ' || *p=='\t' || *p=='\n' || *p=='\r'))
340 node = node_new (METHOD_NODE,
345 "gtktypes:steal", gtktypes,
346 "flags:steal", flags,
348 "args:steal", funcargs,
349 "onerror:steal", onerror,
350 "defreturn:steal", defreturn,
351 "cbuf:steal", c_cbuf,
353 "ccode_line", ccode_line,
355 "unique_id", method_unique_id++,
358 last_added_method = (Method *)node;
362 /*only free segment if we haven't passed it
371 class_nodes = g_list_append(class_nodes, node);
375 free_all_global_state(void)
385 g_list_foreach(gtktypes, (GFunc)g_free, NULL);
386 g_list_free(gtktypes);
389 node_list_free (funcargs);
394 push_funcarg(char *name, char *postfix)
397 Type *type = pop_type();
399 type->postfix = postfix;
401 node = node_new (FUNCARG_NODE,
404 "checks:steal", checks,
408 funcargs = g_list_append(funcargs, node);
412 push_init_arg(char *name, int is_class)
419 tn = g_strconcat(((Class *)class)->otype,":Class",NULL);
421 tn = g_strdup(((Class *)class)->otype);
423 type = node_new (TYPE_NODE,
427 node = node_new (FUNCARG_NODE,
428 "atype:steal", (Type *)type,
431 funcargs = g_list_prepend(funcargs, node);
435 push_self(char *id, gboolean constant)
440 type = node_new (TYPE_NODE,
441 "name", ((Class *)class)->otype,
442 "pointer", constant ? "const *" : "*",
444 ch = g_list_append (ch, node_new (CHECK_NODE,
445 "chtype", NULL_CHECK,
447 ch = g_list_append (ch, node_new (CHECK_NODE,
448 "chtype", TYPE_CHECK,
450 node = node_new (FUNCARG_NODE,
451 "atype:steal", (Type *)type,
455 funcargs = g_list_prepend(funcargs, node);
459 find_var_or_die(const char *id, int line)
463 for(li = class_nodes; li != NULL; li = li->next) {
465 Node *node = li->data;
466 if(node->type != VARIABLE_NODE)
469 if(strcmp(var->id, id)==0)
473 error_printf(GOB_ERROR, line, _("Variable %s not defined here"), id);
475 g_assert_not_reached();
480 set_return_value(char *type, char *val)
482 if(strcmp(type, "onerror")==0) {
488 } else if(strcmp(type, "defreturn")==0) {
499 export_accessors (const char *var_name,
511 the_type = (Type *)node_copy ((Node *)type);
513 the_type = get_tree_type (gtktype, TRUE);
515 if (the_type == NULL) {
516 error_print (GOB_ERROR, line_no,
517 _("Cannot determine type of property or argument"));
522 char *get_id = g_strdup_printf ("get_%s", var_name);
523 GString *get_cbuf = g_string_new (NULL);
524 Node *node1 = node_new (TYPE_NODE,
525 "name", the_type->name,
526 "pointer", the_type->pointer,
527 "postfix", the_type->postfix,
529 Node *node3 = node_new (TYPE_NODE,
530 "name", class->class.otype,
534 g_string_sprintf (get_cbuf,
536 "g_object_get (G_OBJECT (self), \"%s\", "
540 the_type->pointer ? the_type->pointer : "",
543 typestack = g_list_prepend (typestack, node1);
544 typestack = g_list_prepend (typestack, node3);
546 push_funcarg ("self", FALSE);
548 push_function (PUBLIC_SCOPE, REGULAR_METHOD, NULL,
549 get_id, get_cbuf, get_lineno,
550 lineno, FALSE, NULL);
554 char *set_id = g_strdup_printf ("set_%s", var_name);
555 GString *set_cbuf = g_string_new (NULL);
556 Node *node1 = node_new (TYPE_NODE,
557 "name", the_type->name,
558 "pointer", the_type->pointer,
559 "postfix", the_type->postfix,
561 Node *node2 = node_new (TYPE_NODE,
564 Node *node3 = node_new (TYPE_NODE,
565 "name", class->class.otype,
569 g_string_sprintf (set_cbuf,
570 "\tg_object_set (G_OBJECT (self), "
571 "\"%s\", val, NULL);\n",
574 typestack = g_list_prepend (typestack, node2);
575 typestack = g_list_prepend (typestack, node1);
576 typestack = g_list_prepend (typestack, node3);
578 push_funcarg ("self", FALSE);
579 push_funcarg ("val", FALSE);
581 typestack = g_list_prepend (typestack, node2);
582 push_function (PUBLIC_SCOPE, REGULAR_METHOD, NULL,
583 set_id, set_cbuf, set_lineno,
584 lineno, FALSE, NULL);
587 node_free ((Node *)the_type);
591 get_prop_enum_flag_cast (Property *prop)
594 if (prop->extra_gtktype == NULL ||
595 /* HACK! just in case someone made this
596 * work with 2.0.0 by using the TYPE
598 ((strstr (prop->extra_gtktype, "_TYPE_") != NULL ||
599 strstr (prop->extra_gtktype, "TYPE_") == prop->extra_gtktype) &&
600 strchr (prop->extra_gtktype, ':') == NULL)) {
601 if (prop->ptype != NULL)
602 return get_type (prop->ptype, TRUE);
604 return g_strdup ("");
606 tmp = remove_sep (prop->extra_gtktype);
607 ret = g_strdup_printf ("(%s) ", tmp);
613 add_construct_glade (char * file, char * root, char * domain)
617 GList * flags = NULL;
619 type = (Type *)node_new (TYPE_NODE,
623 initializer = g_strdup_printf("\t{\n"
624 "\tGtkWidget * root;\n"
625 "\t%%1$s->_priv->_glade_xml = glade_xml_new(%s, %s, %s);\n"
626 "\troot = glade_xml_get_widget(%%1$s->_priv->_glade_xml, %s);\n"
627 "\tgtk_widget_show(root);\n"
628 "\tgtk_container_add(GTK_CONTAINER(%%1$s), root);\n"
629 "\tglade_xml_signal_autoconnect_full(%%1$s->_priv->_glade_xml, (GladeXMLConnectFunc)___glade_xml_connect_foreach, (gpointer)%%1$s);\n"
630 "}\n", file, root, domain ? domain : "NULL", root);
632 var = node_new (VARIABLE_NODE,
633 "scope", PRIVATE_SCOPE,
635 "glade_widget", FALSE,
636 "id:steal", "_glade_xml",
637 "destructor_unref", FALSE,
638 "destructor", "g_object_unref",
639 "destructor_simple", TRUE,
640 "initializer", initializer,
641 "initializer_simple", FALSE,
643 class_nodes = g_list_prepend(class_nodes, var);
647 property_link_and_export (Node *node)
649 Property *prop = (Property *)node;
653 char *get = NULL, *set = NULL;
656 if (prop->set != NULL ||
658 error_print (GOB_ERROR, prop->line_no,
659 _("Property linking requested, but "
660 "getters and setters exist"));
663 var = find_var_or_die (prop->name, prop->line_no);
664 if(var->scope == PRIVATE_SCOPE) {
665 root = "self->_priv";
666 } else if (var->scope == CLASS_SCOPE) {
667 root = "SELF_GET_CLASS(self)";
669 error_print (GOB_ERROR, prop->line_no,
670 _("Self aliases needed when autolinking to a classwide member"));
675 if (strcmp (prop->gtktype, "STRING") == 0) {
676 set = g_strdup_printf("{ char *old = %s->%s; "
677 "%s->%s = g_value_dup_string (VAL); g_free (old); }",
680 get = g_strdup_printf("g_value_set_string (VAL, %s->%s);",
682 } else if (strcmp (prop->gtktype, "OBJECT") == 0) {
684 if (prop->extra_gtktype != NULL) {
685 cast = remove_sep (prop->extra_gtktype);
687 cast = g_strdup ("void");
689 set = g_strdup_printf("{ GObject *___old = (GObject *)%s->%s; "
690 "%s->%s = (%s *)g_value_dup_object (VAL); "
691 "if (___old != NULL) { "
692 "g_object_unref (G_OBJECT (___old)); "
698 get = g_strdup_printf ("g_value_set_object (VAL, "
699 "(gpointer)%s->%s);",
702 } else if (strcmp (prop->gtktype, "BOXED") == 0) {
703 char *type = make_me_type (prop->extra_gtktype,
705 if (prop->extra_gtktype == NULL) {
706 error_print (GOB_ERROR, prop->line_no,
707 _("Property linking requested for BOXED, but "
708 "boxed_type not set"));
710 set = g_strdup_printf("{ gpointer ___old = (gpointer)%s->%s; "
711 "gpointer ___new = (gpointer)g_value_get_boxed (VAL); "
712 "if (___new != ___old) { "
713 "if (___old != NULL) g_boxed_free (%s, ___old); "
714 "if (___new != NULL) %s->%s = g_boxed_copy (%s, ___new); "
715 "else %s->%s = NULL;"
723 get = g_strdup_printf("g_value_set_boxed (VAL, %s->%s);",
729 const char *getcast = "";
730 const char *setcast = "";
731 char *to_free = NULL;
732 set_func = g_strdup_printf ("g_value_set_%s", prop->gtktype);
733 g_strdown (set_func);
734 get_func = g_strdup_printf ("g_value_get_%s", prop->gtktype);
735 g_strdown (get_func);
738 if (strcmp (prop->gtktype, "FLAGS") == 0) {
739 setcast = "(guint) ";
741 get_prop_enum_flag_cast (prop);
742 } else if (strcmp (prop->gtktype, "ENUM") == 0) {
745 get_prop_enum_flag_cast (prop);
746 } else if (strcmp (prop->gtktype, "POINTER") == 0) {
747 setcast = "(gpointer) ";
748 getcast = g_strdup_printf ("(%s%s) ",
750 prop->ptype->pointer ? prop->ptype->pointer : "");
754 set = g_strdup_printf("%s->%s = %s%s (VAL);",
758 get = g_strdup_printf("%s (VAL, %s%s->%s);",
770 "get_line", prop->line_no,
772 "set_line", prop->line_no,
777 export_accessors (prop->name,
778 prop->get != NULL, prop->get_line,
779 prop->set != NULL, prop->set_line,
790 if (strcmp (s, "BOOL") == 0) {
791 error_print (GOB_WARN, line_no,
792 _("BOOL type is deprecated, please use BOOLEAN"));
794 return g_strdup ("BOOLEAN");
801 ensure_property (void)
803 if (property == NULL)
804 property = (Property *)node_new (PROPERTY_NODE, NULL);
809 /* Enabling traces. */
814 /* Enabling verbose error messages. */
815 #ifdef YYERROR_VERBOSE
816 # undef YYERROR_VERBOSE
817 # define YYERROR_VERBOSE 1
819 # define YYERROR_VERBOSE 0
822 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
824 typedef union YYSTYPE {
831 /* Line 190 of yacc.c. */
833 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
834 # define YYSTYPE_IS_DECLARED 1
835 # define YYSTYPE_IS_TRIVIAL 1
840 /* Copy the second part of user declarations. */
843 /* Line 213 of yacc.c. */
846 #if ! defined (yyoverflow) || YYERROR_VERBOSE
852 # define YYMALLOC malloc
855 /* The parser invokes alloca or malloc; define the necessary symbols. */
857 # ifdef YYSTACK_USE_ALLOCA
858 # if YYSTACK_USE_ALLOCA
860 # define YYSTACK_ALLOC __builtin_alloca
862 # define YYSTACK_ALLOC alloca
867 # ifdef YYSTACK_ALLOC
868 /* Pacify GCC's `empty if-body' warning. */
869 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
871 # if defined (__STDC__) || defined (__cplusplus)
872 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
873 # define YYSIZE_T size_t
875 # define YYSTACK_ALLOC YYMALLOC
876 # define YYSTACK_FREE YYFREE
878 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
881 #if (! defined (yyoverflow) \
882 && (! defined (__cplusplus) \
883 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
885 /* A type that is properly aligned for any stack member. */
892 /* The size of the maximum gap between one aligned stack and the next. */
893 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
895 /* The size of an array large to enough to hold all stacks, each with
897 # define YYSTACK_BYTES(N) \
898 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
899 + YYSTACK_GAP_MAXIMUM)
901 /* Copy COUNT objects from FROM to TO. The source and destination do
904 # if defined (__GNUC__) && 1 < __GNUC__
905 # define YYCOPY(To, From, Count) \
906 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
908 # define YYCOPY(To, From, Count) \
911 register YYSIZE_T yyi; \
912 for (yyi = 0; yyi < (Count); yyi++) \
913 (To)[yyi] = (From)[yyi]; \
919 /* Relocate STACK from its old location to the new one. The
920 local variables YYSIZE and YYSTACKSIZE give the old and new number of
921 elements in the stack, and YYPTR gives the new location of the
922 stack. Advance YYPTR to a properly aligned location for the next
924 # define YYSTACK_RELOCATE(Stack) \
927 YYSIZE_T yynewbytes; \
928 YYCOPY (&yyptr->Stack, Stack, yysize); \
929 Stack = &yyptr->Stack; \
930 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
931 yyptr += yynewbytes / sizeof (*yyptr); \
937 #if defined (__STDC__) || defined (__cplusplus)
938 typedef signed char yysigned_char;
940 typedef short int yysigned_char;
943 /* YYFINAL -- State number of the termination state. */
945 /* YYLAST -- Last index in YYTABLE. */
948 /* YYNTOKENS -- Number of terminals. */
950 /* YYNNTS -- Number of nonterminals. */
952 /* YYNRULES -- Number of rules. */
954 /* YYNRULES -- Number of states. */
955 #define YYNSTATES 414
957 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
959 #define YYMAXUTOK 307
961 #define YYTRANSLATE(YYX) \
962 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
964 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
965 static const unsigned char yytranslate[] =
967 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
968 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
969 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
970 2, 2, 2, 64, 2, 2, 2, 2, 2, 2,
971 55, 56, 61, 2, 59, 65, 2, 2, 2, 2,
972 2, 2, 2, 2, 2, 2, 2, 2, 2, 57,
973 63, 58, 62, 2, 2, 2, 2, 2, 2, 2,
974 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
975 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
976 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
977 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
978 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
979 2, 2, 2, 53, 60, 54, 2, 2, 2, 2,
980 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
981 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
982 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
983 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
984 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
985 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
986 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
987 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
988 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
989 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
990 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
991 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
992 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
993 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
994 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
995 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
996 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
997 45, 46, 47, 48, 49, 50, 51, 52
1001 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1003 static const unsigned short int yyprhs[] =
1005 0, 0, 3, 7, 10, 13, 15, 17, 19, 21,
1006 23, 25, 27, 30, 33, 36, 39, 41, 43, 45,
1007 47, 52, 56, 62, 63, 68, 74, 80, 86, 93,
1008 101, 108, 116, 119, 121, 123, 126, 130, 132, 134,
1009 136, 138, 140, 142, 144, 146, 149, 153, 156, 160,
1010 163, 166, 168, 170, 172, 173, 179, 186, 199, 209,
1011 216, 220, 221, 233, 242, 248, 252, 253, 257, 259,
1012 261, 266, 268, 270, 274, 278, 282, 286, 290, 294,
1013 298, 302, 306, 310, 314, 318, 322, 326, 330, 334,
1014 338, 340, 346, 348, 352, 353, 357, 359, 362, 364,
1015 366, 368, 371, 374, 377, 381, 385, 388, 391, 394,
1016 396, 399, 401, 404, 406, 408, 410, 412, 414, 416,
1017 418, 420, 422, 424, 426, 428, 430, 433, 436, 440,
1018 443, 445, 449, 453, 456, 458, 463, 467, 469, 472,
1019 474, 485, 497, 507, 517, 526, 538, 547, 553, 556,
1020 561, 562, 564, 567, 569, 571, 574, 577, 581, 586,
1021 591, 593, 597, 599, 603, 605, 608, 612, 619, 627,
1022 630, 632, 634, 637, 640, 644, 648, 652, 656, 664,
1023 673, 677, 679, 683, 685, 693, 702, 706, 708, 716,
1024 725, 729, 731, 733, 736, 738
1027 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1028 static const yysigned_char yyrhs[] =
1030 67, 0, -1, 69, 70, 69, -1, 70, 69, -1,
1031 69, 70, -1, 70, -1, 24, -1, 27, -1, 25,
1032 -1, 26, -1, 28, -1, 29, -1, 69, 68, -1,
1033 69, 111, -1, 69, 114, -1, 69, 116, -1, 68,
1034 -1, 111, -1, 114, -1, 116, -1, 71, 53, 73,
1035 54, -1, 71, 53, 54, -1, 3, 21, 4, 21,
1036 72, -1, -1, 55, 19, 56, 72, -1, 55, 19,
1037 19, 56, 72, -1, 55, 19, 21, 56, 72, -1,
1038 55, 19, 20, 56, 72, -1, 55, 19, 30, 30,
1039 56, 72, -1, 55, 19, 30, 30, 30, 56, 72,
1040 -1, 55, 19, 19, 30, 56, 72, -1, 55, 19,
1041 19, 30, 30, 56, 72, -1, 73, 74, -1, 74,
1042 -1, 102, -1, 19, 102, -1, 19, 21, 102, -1,
1043 79, -1, 80, -1, 82, -1, 57, -1, 31, -1,
1044 32, -1, 33, -1, 34, -1, 19, 19, -1, 19,
1045 53, 24, -1, 58, 118, -1, 58, 53, 24, -1,
1046 76, 77, -1, 77, 76, -1, 77, -1, 76, -1,
1047 19, -1, -1, 75, 91, 19, 78, 57, -1, 75,
1048 91, 19, 22, 78, 57, -1, 36, 89, 88, 19,
1049 81, 19, 53, 24, 19, 53, 24, 57, -1, 36,
1050 89, 88, 19, 81, 19, 53, 24, 57, -1, 36,
1051 89, 88, 19, 81, 19, -1, 55, 19, 56, -1,
1052 -1, 35, 19, 19, 83, 19, 53, 24, 19, 53,
1053 24, 57, -1, 35, 19, 19, 83, 19, 53, 24,
1054 57, -1, 35, 19, 19, 83, 57, -1, 55, 84,
1055 56, -1, -1, 84, 59, 87, -1, 87, -1, 30,
1056 -1, 19, 55, 30, 56, -1, 118, -1, 85, -1,
1057 40, 58, 85, -1, 41, 58, 85, -1, 42, 58,
1058 118, -1, 43, 58, 118, -1, 44, 58, 86, -1,
1059 46, 58, 90, -1, 47, 58, 91, -1, 48, 58,
1060 21, -1, 48, 58, 19, -1, 49, 58, 21, -1,
1061 49, 58, 19, -1, 50, 58, 21, -1, 50, 58,
1062 19, -1, 51, 58, 21, -1, 51, 58, 19, -1,
1063 52, 58, 21, -1, 52, 58, 19, -1, 19, -1,
1064 19, 55, 19, 91, 56, -1, 19, -1, 55, 90,
1065 56, -1, -1, 19, 60, 90, -1, 19, -1, 92,
1066 96, -1, 92, -1, 93, -1, 19, -1, 5, 19,
1067 -1, 19, 5, -1, 95, 19, -1, 5, 95, 19,
1068 -1, 95, 19, 5, -1, 94, 93, -1, 21, 93,
1069 -1, 5, 93, -1, 21, -1, 21, 5, -1, 94,
1070 -1, 94, 5, -1, 6, -1, 18, -1, 14, -1,
1071 15, -1, 13, -1, 16, -1, 17, -1, 11, -1,
1072 12, -1, 7, -1, 8, -1, 9, -1, 61, -1,
1073 61, 5, -1, 61, 96, -1, 61, 5, 96, -1,
1074 19, 99, -1, 99, -1, 75, 19, 99, -1, 19,
1075 75, 99, -1, 75, 99, -1, 97, -1, 19, 55,
1076 100, 56, -1, 100, 59, 19, -1, 19, -1, 53,
1077 24, -1, 57, -1, 38, 89, 98, 91, 19, 55,
1078 105, 56, 103, 101, -1, 75, 38, 89, 97, 91,
1079 19, 55, 105, 56, 103, 101, -1, 37, 75, 91,
1080 19, 55, 105, 56, 103, 101, -1, 75, 37, 91,
1081 19, 55, 105, 56, 103, 101, -1, 37, 91, 19,
1082 55, 105, 56, 103, 101, -1, 39, 55, 21, 56,
1083 91, 19, 55, 105, 56, 103, 101, -1, 75, 91,
1084 19, 55, 105, 56, 103, 101, -1, 19, 55, 19,
1085 56, 101, -1, 19, 104, -1, 19, 104, 19, 104,
1086 -1, -1, 118, -1, 53, 24, -1, 6, -1, 19,
1087 -1, 19, 5, -1, 5, 19, -1, 19, 59, 106,
1088 -1, 19, 5, 59, 106, -1, 5, 19, 59, 106,
1089 -1, 106, -1, 107, 59, 10, -1, 107, -1, 107,
1090 59, 108, -1, 108, -1, 91, 19, -1, 91, 19,
1091 22, -1, 91, 19, 55, 19, 109, 56, -1, 91,
1092 19, 22, 55, 19, 109, 56, -1, 109, 110, -1,
1093 110, -1, 19, -1, 62, 118, -1, 63, 118, -1,
1094 62, 58, 118, -1, 63, 58, 118, -1, 58, 58,
1095 118, -1, 64, 58, 118, -1, 9, 19, 53, 112,
1096 54, 21, 57, -1, 9, 19, 53, 112, 59, 54,
1097 21, 57, -1, 112, 59, 113, -1, 113, -1, 19,
1098 58, 118, -1, 19, -1, 46, 19, 53, 115, 54,
1099 21, 57, -1, 46, 19, 53, 115, 59, 54, 21,
1100 57, -1, 115, 59, 19, -1, 19, -1, 45, 19,
1101 53, 117, 54, 21, 57, -1, 45, 19, 53, 117,
1102 59, 54, 21, 57, -1, 117, 59, 19, -1, 19,
1103 -1, 20, -1, 65, 20, -1, 23, -1, 19, -1
1106 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1107 static const unsigned short int yyrline[] =
1109 0, 689, 689, 690, 691, 692, 695, 704, 713, 722,
1110 731, 740, 751, 752, 753, 754, 755, 756, 757, 758,
1111 761, 766, 773, 790, 791, 799, 811, 820, 832, 841,
1112 850, 859, 870, 871, 874, 875, 884, 896, 897, 898,
1113 899, 902, 903, 904, 905, 908, 928, 952, 956, 964,
1114 965, 966, 967, 968, 976, 982, 985, 990, 1058, 1112,
1115 1201, 1209, 1214, 1262, 1298, 1314, 1315, 1318, 1319, 1322,
1116 1323, 1335, 1336, 1339, 1345, 1351, 1357, 1363, 1369, 1375,
1117 1382, 1388, 1394, 1400, 1406, 1412, 1418, 1424, 1430, 1436,
1118 1442, 1467, 1476, 1482, 1483, 1486, 1489, 1495, 1502, 1511,
1119 1514, 1517, 1521, 1525, 1529, 1534, 1542, 1546, 1551, 1555,
1120 1558, 1562, 1565, 1570, 1571, 1572, 1573, 1574, 1575, 1576,
1121 1577, 1578, 1581, 1582, 1583, 1586, 1587, 1588, 1592, 1599,
1122 1611, 1617, 1629, 1641, 1644, 1650, 1655, 1658, 1663, 1664,
1123 1668, 1684, 1700, 1716, 1732, 1743, 1749, 1759, 1782, 1793,
1124 1812, 1818, 1819, 1825, 1826, 1837, 1848, 1859, 1869, 1879,
1125 1889, 1892, 1893, 1896, 1897, 1900, 1903, 1906, 1914, 1924,
1126 1925, 1928, 1945, 1952, 1959, 1966, 1973, 1980, 1989, 1998,
1127 2009, 2010, 2013, 2033, 2043, 2052, 2063, 2066, 2071, 2080,
1128 2091, 2094, 2100, 2101, 2105, 2106
1132 #if YYDEBUG || YYERROR_VERBOSE
1133 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1134 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1135 static const char *const yytname[] =
1137 "$end", "error", "$undefined", "CLASS", "FROM", "CONST", "VOID",
1138 "STRUCT", "UNION", "ENUM", "THREEDOTS", "SIGNED", "UNSIGNED", "LONG",
1139 "SHORT", "INT", "FLOAT", "DOUBLE", "CHAR", "TOKEN", "NUMBER",
1140 "TYPETOKEN", "ARRAY_DIM", "SINGLE_CHAR", "CCODE", "HTCODE", "PHCODE",
1141 "HCODE", "ACODE", "ATCODE", "STRING", "PUBLIC", "PRIVATE", "PROTECTED",
1142 "CLASSWIDE", "PROPERTY", "ARGUMENT", "VIRTUAL", "SIGNAL", "OVERRIDE",
1143 "NICK", "BLURB", "MAXIMUM", "MINIMUM", "DEFAULT_VALUE", "ERROR", "FLAGS",
1144 "TYPE", "FLAGS_TYPE", "ENUM_TYPE", "PARAM_TYPE", "BOXED_TYPE",
1145 "OBJECT_TYPE", "'{'", "'}'", "'('", "')'", "';'", "'='", "','", "'|'",
1146 "'*'", "'>'", "'<'", "'!'", "'-'", "$accept", "prog", "ccode", "ccodes",
1147 "class", "classdec", "classflags", "classcode", "thing", "scope",
1148 "destructor", "initializer", "varoptions", "variable", "argument",
1149 "export", "property", "param_spec", "param_spec_list", "string",
1150 "anyval", "param_spec_value", "argtype", "flags", "flaglist", "type",
1151 "specifier_list", "spec_list", "specifier", "strunionenum", "pointer",
1152 "simplesigtype", "fullsigtype", "sigtype", "tokenlist", "codenocode",
1153 "method", "returnvals", "retcode", "funcargs", "arglist", "arglist1",
1154 "arg", "checklist", "check", "enumcode", "enumvals", "enumval",
1155 "flagcode", "flagvals", "errorcode", "errorvals", "numtok", 0
1160 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1162 static const unsigned short int yytoknum[] =
1164 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1165 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1166 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1167 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1168 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1169 305, 306, 307, 123, 125, 40, 41, 59, 61, 44,
1170 124, 42, 62, 60, 33, 45
1174 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1175 static const unsigned char yyr1[] =
1177 0, 66, 67, 67, 67, 67, 68, 68, 68, 68,
1178 68, 68, 69, 69, 69, 69, 69, 69, 69, 69,
1179 70, 70, 71, 72, 72, 72, 72, 72, 72, 72,
1180 72, 72, 73, 73, 74, 74, 74, 74, 74, 74,
1181 74, 75, 75, 75, 75, 76, 76, 77, 77, 78,
1182 78, 78, 78, 78, 78, 79, 79, 80, 80, 80,
1183 81, 81, 82, 82, 82, 83, 83, 84, 84, 85,
1184 85, 86, 86, 87, 87, 87, 87, 87, 87, 87,
1185 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
1186 87, 88, 88, 89, 89, 90, 90, 91, 91, 92,
1187 92, 92, 92, 92, 92, 92, 93, 93, 93, 93,
1188 93, 93, 93, 94, 94, 94, 94, 94, 94, 94,
1189 94, 94, 95, 95, 95, 96, 96, 96, 96, 97,
1190 97, 98, 98, 98, 98, 99, 100, 100, 101, 101,
1191 102, 102, 102, 102, 102, 102, 102, 102, 103, 103,
1192 103, 104, 104, 105, 105, 105, 105, 105, 105, 105,
1193 105, 106, 106, 107, 107, 108, 108, 108, 108, 109,
1194 109, 110, 110, 110, 110, 110, 110, 110, 111, 111,
1195 112, 112, 113, 113, 114, 114, 115, 115, 116, 116,
1196 117, 117, 118, 118, 118, 118
1199 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1200 static const unsigned char yyr2[] =
1202 0, 2, 3, 2, 2, 1, 1, 1, 1, 1,
1203 1, 1, 2, 2, 2, 2, 1, 1, 1, 1,
1204 4, 3, 5, 0, 4, 5, 5, 5, 6, 7,
1205 6, 7, 2, 1, 1, 2, 3, 1, 1, 1,
1206 1, 1, 1, 1, 1, 2, 3, 2, 3, 2,
1207 2, 1, 1, 1, 0, 5, 6, 12, 9, 6,
1208 3, 0, 11, 8, 5, 3, 0, 3, 1, 1,
1209 4, 1, 1, 3, 3, 3, 3, 3, 3, 3,
1210 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1211 1, 5, 1, 3, 0, 3, 1, 2, 1, 1,
1212 1, 2, 2, 2, 3, 3, 2, 2, 2, 1,
1213 2, 1, 2, 1, 1, 1, 1, 1, 1, 1,
1214 1, 1, 1, 1, 1, 1, 2, 2, 3, 2,
1215 1, 3, 3, 2, 1, 4, 3, 1, 2, 1,
1216 10, 11, 9, 9, 8, 11, 8, 5, 2, 4,
1217 0, 1, 2, 1, 1, 2, 2, 3, 4, 4,
1218 1, 3, 1, 3, 1, 2, 3, 6, 7, 2,
1219 1, 1, 2, 2, 3, 3, 3, 3, 7, 8,
1220 3, 1, 3, 1, 7, 8, 3, 1, 7, 8,
1224 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1225 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1226 means the default is an error. */
1227 static const unsigned char yydefact[] =
1229 0, 0, 0, 6, 8, 9, 7, 10, 11, 0,
1230 0, 0, 16, 0, 5, 0, 17, 18, 19, 0,
1231 0, 0, 0, 1, 12, 4, 13, 14, 15, 3,
1232 0, 0, 0, 0, 0, 2, 0, 41, 42, 43,
1233 44, 0, 94, 0, 94, 0, 21, 40, 0, 33,
1234 0, 37, 38, 39, 34, 23, 183, 0, 181, 191,
1235 0, 187, 0, 0, 0, 0, 0, 35, 0, 0,
1236 0, 0, 113, 122, 123, 124, 120, 121, 117, 115,
1237 116, 118, 119, 114, 100, 109, 0, 0, 98, 99,
1238 111, 0, 0, 0, 20, 32, 0, 94, 0, 0,
1239 22, 0, 0, 0, 0, 0, 0, 0, 36, 0,
1240 0, 66, 96, 0, 92, 0, 0, 101, 108, 0,
1241 102, 110, 107, 0, 0, 125, 97, 112, 106, 103,
1242 0, 0, 134, 0, 130, 0, 0, 0, 54, 0,
1243 195, 192, 194, 0, 182, 0, 0, 180, 0, 190,
1244 0, 0, 186, 0, 0, 0, 0, 0, 0, 93,
1245 0, 61, 104, 0, 0, 126, 127, 105, 0, 0,
1246 0, 129, 0, 133, 0, 0, 0, 0, 0, 53,
1247 54, 0, 0, 52, 51, 0, 0, 0, 0, 0,
1248 23, 193, 178, 0, 188, 0, 184, 0, 0, 139,
1249 147, 90, 0, 0, 0, 0, 0, 0, 0, 0,
1250 0, 0, 0, 0, 0, 68, 0, 64, 95, 0,
1251 0, 0, 0, 0, 113, 100, 0, 0, 160, 162,
1252 164, 128, 137, 0, 132, 131, 0, 0, 0, 0,
1253 45, 0, 0, 0, 0, 47, 49, 0, 50, 55,
1254 0, 23, 23, 23, 0, 24, 179, 189, 185, 138,
1255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1256 0, 0, 65, 0, 0, 0, 0, 59, 0, 101,
1257 102, 0, 165, 150, 0, 135, 0, 0, 0, 0,
1258 0, 46, 56, 150, 48, 0, 23, 25, 27, 26,
1259 0, 23, 0, 69, 73, 74, 75, 76, 195, 72,
1260 77, 71, 78, 79, 81, 80, 83, 82, 85, 84,
1261 87, 86, 89, 88, 67, 0, 91, 60, 0, 150,
1262 0, 0, 157, 166, 0, 0, 0, 161, 163, 136,
1263 0, 0, 150, 0, 0, 23, 30, 23, 28, 0,
1264 0, 63, 0, 0, 159, 158, 0, 0, 0, 148,
1265 151, 144, 150, 0, 0, 0, 146, 31, 29, 0,
1266 0, 0, 58, 142, 0, 171, 0, 0, 0, 0,
1267 0, 170, 152, 0, 0, 150, 143, 150, 70, 0,
1268 0, 0, 0, 0, 172, 0, 173, 0, 167, 169,
1269 149, 140, 0, 0, 62, 0, 168, 176, 174, 175,
1273 /* YYDEFGOTO[NTERM-NUM]. */
1274 static const short int yydefgoto[] =
1276 -1, 11, 12, 13, 14, 15, 100, 48, 49, 50,
1277 183, 184, 185, 51, 52, 221, 53, 157, 214, 304,
1278 310, 215, 115, 70, 113, 226, 88, 89, 90, 91,
1279 126, 132, 133, 134, 233, 200, 54, 336, 359, 227,
1280 228, 229, 230, 380, 381, 16, 57, 58, 17, 62,
1284 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1286 #define YYPACT_NINF -325
1287 static const short int yypact[] =
1289 144, -5, 92, -325, -325, -325, -325, -325, -325, 98,
1290 99, 123, -325, 144, 167, 78, -325, -325, -325, 161,
1291 121, 154, 182, -325, -325, 167, -325, -325, -325, 167,
1292 148, 179, 217, 227, 228, 167, 211, -325, -325, -325,
1293 -325, 237, 229, 326, 229, 234, -325, -325, 184, -325,
1294 292, -325, -325, -325, -325, 263, 261, -31, -325, -325,
1295 147, -325, 174, 268, 283, 309, 292, -325, 317, 330,
1296 331, 373, -325, -325, -325, -325, -325, -325, -325, -325,
1297 -325, -325, -325, -325, 346, 441, 390, 333, 294, -325,
1298 455, 334, 293, 335, -325, -325, 390, 229, 357, 364,
1299 -325, 75, 372, 38, 379, 50, 389, 95, -325, 298,
1300 398, 393, 367, 378, 394, 425, 469, -325, -325, 431,
1301 -325, 469, -325, 432, 408, 5, -325, 469, -325, 459,
1302 220, 446, -325, 390, -325, 421, 460, 470, 156, 178,
1303 -325, -325, -325, 458, -325, 434, 467, -325, 435, -325,
1304 472, 437, -325, 474, 202, 442, 221, 39, 330, -325,
1305 477, 443, -325, 444, 407, 294, -325, -325, 445, 482,
1306 483, -325, -6, -325, 484, 390, 449, -6, 390, 101,
1307 31, 407, 15, 447, 487, 450, -15, 452, 453, 480,
1308 263, -325, -325, 454, -325, 456, -325, 457, 488, -325,
1309 -325, -325, 461, 462, 463, 464, 465, 466, 468, 471,
1310 473, 475, 476, 478, -23, -325, 479, -325, -325, 390,
1311 496, 497, 407, 424, 481, 14, 498, 485, -325, 486,
1312 -325, -325, -325, 201, -325, -325, 489, 499, 407, 506,
1313 -325, 503, 490, 492, 504, -325, -325, 101, -325, -325,
1314 100, 263, 263, 263, 104, -325, -325, -325, -325, -325,
1315 2, 2, 75, 75, 7, 330, 390, 208, 266, 269,
1316 274, 327, -325, 221, 511, 493, 494, 500, 495, 222,
1317 223, 390, 87, 519, 356, -325, 520, 407, 491, 501,
1318 505, -325, -325, 519, -325, 502, 263, -325, -325, -325,
1319 507, 263, 509, -325, -325, -325, -325, -325, 509, -325,
1320 -325, -325, -325, -325, -325, -325, -325, -325, -325, -325,
1321 -325, -325, -325, -325, -325, 58, -325, -325, 516, 519,
1322 390, 390, -325, 510, 523, 32, 202, -325, -325, -325,
1323 512, 407, 519, 407, 202, 263, -325, 263, -325, 513,
1324 508, -325, 71, 202, -325, -325, 533, 88, 530, 536,
1325 -325, -325, 519, 514, 202, 515, -325, -325, -325, 517,
1326 532, 521, -325, -325, 88, -325, 518, 64, 83, 522,
1327 63, -325, -325, 32, 202, 519, -325, 519, -325, 524,
1328 535, 81, 75, 75, -325, 75, -325, 75, -325, -325,
1329 -325, -325, 202, 202, -325, 525, -325, -325, -325, -325,
1330 -325, -325, -325, -325
1333 /* YYPGOTO[NTERM-NUM]. */
1334 static const short int yypgoto[] =
1336 -325, -325, 103, 110, 549, -325, -188, -325, 527, -25,
1337 382, 347, 387, -325, -325, -325, -325, -325, -325, 22,
1338 -325, 296, -325, -35, -153, -42, -325, -68, -325, -65,
1339 -94, 440, -325, -84, -325, -324, -22, -286, 189, -177,
1340 -256, -325, 295, 204, -154, 175, -325, 526, 196, -325,
1344 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1345 positive, shift that token. If negative, reduce the rule which
1346 number is the opposite. If zero, do what YYDEFACT says.
1347 If YYTABLE_NINF, syntax error. */
1348 #define YYTABLE_NINF -157
1349 static const short int yytable[] =
1351 144, 87, 255, 118, 243, 218, 119, 344, 98, 92,
1352 165, 66, 361, 168, 67, 250, 19, 122, 86, 280,
1353 366, 302, 128, 102, 110, 332, 308, 141, 103, 373,
1354 142, 166, 303, 272, 140, 141, 273, 303, 142, 66,
1355 386, 251, 108, 353, 123, 278, 171, 173, 118, 169,
1356 179, 140, 141, 118, 136, 142, 364, 56, 216, 118,
1357 401, 289, 137, 297, 298, 299, 125, 131, 244, 149,
1358 -154, 231, 143, 281, 354, 355, 384, 350, 411, 412,
1359 143, 245, 375, 140, 141, 358, 234, 142, 235, 182,
1360 371, 174, 146, 171, 140, 141, 217, 143, 142, 402,
1361 375, 403, 140, 141, 150, 170, 142, 375, 346, 333,
1362 340, 20, 312, 348, 152, 351, 24, 21, 22, 398,
1363 240, 376, 393, 23, 29, 377, 378, 379, 372, 143,
1364 295, 30, 24, 237, 300, 35, 239, 406, 24, 376,
1365 143, 395, 334, 377, 378, 379, 376, 1, 143, 153,
1366 377, 378, 379, 2, 241, 118, 296, 367, 119, 368,
1367 301, 306, 307, 311, 363, 31, 365, 36, 3, 4,
1368 5, 6, 7, 8, 32, 179, 2, 275, 180, 37,
1369 38, 39, 40, 41, 42, 43, 44, 45, 26, 9,
1370 10, 3, 4, 5, 6, 7, 8, 186, 187, 188,
1371 55, 104, 46, 36, 26, 47, 105, 33, 189, 27,
1372 26, 181, 9, 10, 182, 37, 38, 39, 40, 41,
1373 42, 43, 44, 45, 313, 27, 399, 314, 106, 315,
1374 63, 27, 64, 107, 190, 34, 56, 399, 94, 168,
1375 201, 47, 37, 38, 39, 40, 59, 61, 43, 44,
1376 45, 37, 38, 39, 40, 198, 68, 285, 28, 199,
1377 286, 202, 203, 204, 205, 206, 65, 207, 208, 209,
1378 210, 211, 212, 213, 28, 169, 394, 396, -156, -155,
1379 28, 330, 331, 305, 69, 316, 309, 317, 318, 93,
1380 319, 407, 408, 320, 409, 321, 410, 71, 72, 73,
1381 74, 75, 63, 76, 77, 78, 79, 80, 81, 82,
1382 83, 84, 130, 85, 37, 38, 39, 40, 99, 101,
1383 43, 44, 45, 65, 37, 38, 39, 40, 109, 96,
1384 97, 71, 72, 73, 74, 75, 111, 76, 77, 78,
1385 79, 80, 81, 82, 83, 84, 322, 85, 323, 112,
1386 114, 120, 124, 129, 154, 125, 135, 37, 38, 39,
1387 40, 71, 72, 73, 74, 75, 337, 76, 77, 78,
1388 79, 80, 81, 82, 83, 84, 138, 85, 116, 72,
1389 73, 74, 75, 139, 76, 77, 78, 79, 80, 81,
1390 82, 83, 117, 145, 85, 71, 72, 73, 74, 75,
1391 148, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1392 151, 85, 223, 224, 73, 74, 75, 155, 76, 77,
1393 78, 79, 80, 81, 82, 83, 225, 158, 85, 116,
1394 72, 73, 74, 75, 159, 76, 77, 78, 79, 80,
1395 81, 82, 83, 279, 161, 85, 121, 72, 156, 160,
1396 162, 163, 76, 77, 78, 79, 80, 81, 82, 83,
1397 127, 72, 85, 164, 167, 172, 76, 77, 78, 79,
1398 80, 81, 82, 83, 116, 72, 85, 175, 191, 176,
1399 76, 77, 78, 79, 80, 81, 82, 83, 193, 177,
1400 85, 192, 194, 195, 196, 197, 219, 181, 220, 222,
1401 169, 232, 168, 236, 238, 182, 247, 249, 252, 253,
1402 254, 256, 259, 257, 258, 276, 277, 282, 288, 260,
1403 261, 262, 263, 264, 265, 290, 266, 291, 294, 267,
1404 246, 268, 274, 269, 270, 325, 271, -153, 335, 339,
1405 352, 283, 357, 369, 287, 284, 341, 292, 293, 326,
1406 327, 329, 374, 328, 382, 383, 389, 342, 345, 405,
1407 343, 370, 25, 347, 349, 356, 248, 242, 362, 324,
1408 385, 387, 400, 388, 390, 95, 392, 178, 391, 338,
1409 397, 404, 413, 0, 0, 0, 0, 0, 0, 0,
1410 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1411 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1412 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1413 0, 0, 0, 0, 0, 0, 0, 0, 0, 147
1416 static const short int yycheck[] =
1418 101, 43, 190, 71, 181, 158, 71, 293, 50, 44,
1419 5, 36, 336, 19, 36, 30, 21, 85, 43, 5,
1420 344, 19, 90, 54, 66, 281, 19, 20, 59, 353,
1421 23, 125, 30, 56, 19, 20, 59, 30, 23, 64,
1422 364, 56, 64, 329, 86, 222, 130, 131, 116, 55,
1423 19, 19, 20, 121, 96, 23, 342, 19, 19, 127,
1424 384, 238, 97, 251, 252, 253, 61, 92, 53, 19,
1425 56, 165, 65, 59, 330, 331, 362, 19, 402, 403,
1426 65, 182, 19, 19, 20, 53, 170, 23, 172, 58,
1427 19, 133, 54, 177, 19, 20, 57, 65, 23, 385,
1428 19, 387, 19, 20, 54, 130, 23, 19, 296, 22,
1429 287, 19, 265, 301, 19, 57, 13, 19, 19, 56,
1430 19, 58, 58, 0, 14, 62, 63, 64, 57, 65,
1431 30, 53, 29, 175, 30, 25, 178, 56, 35, 58,
1432 65, 58, 55, 62, 63, 64, 58, 3, 65, 54,
1433 62, 63, 64, 9, 53, 223, 56, 345, 223, 347,
1434 56, 262, 263, 264, 341, 4, 343, 19, 24, 25,
1435 26, 27, 28, 29, 53, 19, 9, 219, 22, 31,
1436 32, 33, 34, 35, 36, 37, 38, 39, 13, 45,
1437 46, 24, 25, 26, 27, 28, 29, 19, 20, 21,
1438 21, 54, 54, 19, 29, 57, 59, 53, 30, 13,
1439 35, 55, 45, 46, 58, 31, 32, 33, 34, 35,
1440 36, 37, 38, 39, 266, 29, 380, 19, 54, 21,
1441 19, 35, 21, 59, 56, 53, 19, 391, 54, 19,
1442 19, 57, 31, 32, 33, 34, 19, 19, 37, 38,
1443 39, 31, 32, 33, 34, 53, 19, 56, 13, 57,
1444 59, 40, 41, 42, 43, 44, 55, 46, 47, 48,
1445 49, 50, 51, 52, 29, 55, 377, 378, 56, 56,
1446 35, 59, 59, 261, 55, 19, 264, 21, 19, 55,
1447 21, 392, 393, 19, 395, 21, 397, 5, 6, 7,
1448 8, 9, 19, 11, 12, 13, 14, 15, 16, 17,
1449 18, 19, 19, 21, 31, 32, 33, 34, 55, 58,
1450 37, 38, 39, 55, 31, 32, 33, 34, 19, 37,
1451 38, 5, 6, 7, 8, 9, 19, 11, 12, 13,
1452 14, 15, 16, 17, 18, 19, 19, 21, 21, 19,
1453 19, 5, 19, 19, 56, 61, 21, 31, 32, 33,
1454 34, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1455 14, 15, 16, 17, 18, 19, 19, 21, 5, 6,
1456 7, 8, 9, 19, 11, 12, 13, 14, 15, 16,
1457 17, 18, 19, 21, 21, 5, 6, 7, 8, 9,
1458 21, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1459 21, 21, 5, 6, 7, 8, 9, 19, 11, 12,
1460 13, 14, 15, 16, 17, 18, 19, 60, 21, 5,
1461 6, 7, 8, 9, 56, 11, 12, 13, 14, 15,
1462 16, 17, 18, 19, 19, 21, 5, 6, 55, 55,
1463 19, 19, 11, 12, 13, 14, 15, 16, 17, 18,
1464 5, 6, 21, 55, 5, 19, 11, 12, 13, 14,
1465 15, 16, 17, 18, 5, 6, 21, 56, 20, 19,
1466 11, 12, 13, 14, 15, 16, 17, 18, 21, 19,
1467 21, 57, 57, 21, 57, 21, 19, 55, 55, 55,
1468 55, 19, 19, 19, 55, 58, 19, 57, 56, 56,
1469 30, 57, 24, 57, 57, 19, 19, 19, 19, 58,
1470 58, 58, 58, 58, 58, 19, 58, 24, 24, 58,
1471 183, 58, 53, 58, 58, 24, 58, 56, 19, 19,
1472 24, 56, 19, 30, 55, 59, 55, 57, 56, 56,
1473 56, 56, 19, 53, 24, 19, 24, 56, 56, 24,
1474 55, 53, 13, 56, 55, 55, 184, 180, 56, 273,
1475 56, 56, 383, 56, 53, 48, 58, 137, 374, 284,
1476 58, 57, 57, -1, -1, -1, -1, -1, -1, -1,
1477 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1478 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1479 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1480 -1, -1, -1, -1, -1, -1, -1, -1, -1, 103
1483 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1484 symbol of state STATE-NUM. */
1485 static const unsigned char yystos[] =
1487 0, 3, 9, 24, 25, 26, 27, 28, 29, 45,
1488 46, 67, 68, 69, 70, 71, 111, 114, 116, 21,
1489 19, 19, 19, 0, 68, 70, 111, 114, 116, 69,
1490 53, 4, 53, 53, 53, 69, 19, 31, 32, 33,
1491 34, 35, 36, 37, 38, 39, 54, 57, 73, 74,
1492 75, 79, 80, 82, 102, 21, 19, 112, 113, 19,
1493 117, 19, 115, 19, 21, 55, 75, 102, 19, 55,
1494 89, 5, 6, 7, 8, 9, 11, 12, 13, 14,
1495 15, 16, 17, 18, 19, 21, 75, 91, 92, 93,
1496 94, 95, 89, 55, 54, 74, 37, 38, 91, 55,
1497 72, 58, 54, 59, 54, 59, 54, 59, 102, 19,
1498 91, 19, 19, 90, 19, 88, 5, 19, 93, 95,
1499 5, 5, 93, 91, 19, 61, 96, 5, 93, 19,
1500 19, 75, 97, 98, 99, 21, 91, 89, 19, 19,
1501 19, 20, 23, 65, 118, 21, 54, 113, 21, 19,
1502 54, 21, 19, 54, 56, 19, 55, 83, 60, 56,
1503 55, 19, 19, 19, 55, 5, 96, 5, 19, 55,
1504 75, 99, 19, 99, 91, 56, 19, 19, 97, 19,
1505 22, 55, 58, 76, 77, 78, 19, 20, 21, 30,
1506 56, 20, 57, 21, 57, 21, 57, 21, 53, 57,
1507 101, 19, 40, 41, 42, 43, 44, 46, 47, 48,
1508 49, 50, 51, 52, 84, 87, 19, 57, 90, 19,
1509 55, 81, 55, 5, 6, 19, 91, 105, 106, 107,
1510 108, 96, 19, 100, 99, 99, 19, 91, 55, 91,
1511 19, 53, 78, 105, 53, 118, 77, 19, 76, 57,
1512 30, 56, 56, 56, 30, 72, 57, 57, 57, 24,
1513 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
1514 58, 58, 56, 59, 53, 91, 19, 19, 105, 19,
1515 5, 59, 19, 56, 59, 56, 59, 55, 19, 105,
1516 19, 24, 57, 56, 24, 30, 56, 72, 72, 72,
1517 30, 56, 19, 30, 85, 85, 118, 118, 19, 85,
1518 86, 118, 90, 91, 19, 21, 19, 21, 19, 21,
1519 19, 21, 19, 21, 87, 24, 56, 56, 53, 56,
1520 59, 59, 106, 22, 55, 19, 103, 10, 108, 19,
1521 105, 55, 56, 55, 103, 56, 72, 56, 72, 55,
1522 19, 57, 24, 103, 106, 106, 55, 19, 53, 104,
1523 118, 101, 56, 105, 103, 105, 101, 72, 72, 30,
1524 53, 19, 57, 101, 19, 19, 58, 62, 63, 64,
1525 109, 110, 24, 19, 103, 56, 101, 56, 56, 24,
1526 53, 109, 58, 58, 118, 58, 118, 58, 56, 110,
1527 104, 101, 103, 103, 57, 24, 56, 118, 118, 118,
1531 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1532 # define YYSIZE_T __SIZE_TYPE__
1534 #if ! defined (YYSIZE_T) && defined (size_t)
1535 # define YYSIZE_T size_t
1537 #if ! defined (YYSIZE_T)
1538 # if defined (__STDC__) || defined (__cplusplus)
1539 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1540 # define YYSIZE_T size_t
1543 #if ! defined (YYSIZE_T)
1544 # define YYSIZE_T unsigned int
1547 #define yyerrok (yyerrstatus = 0)
1548 #define yyclearin (yychar = YYEMPTY)
1549 #define YYEMPTY (-2)
1552 #define YYACCEPT goto yyacceptlab
1553 #define YYABORT goto yyabortlab
1554 #define YYERROR goto yyerrorlab
1557 /* Like YYERROR except do call yyerror. This remains here temporarily
1558 to ease the transition to the new meaning of YYERROR, for GCC.
1559 Once GCC version 2 has supplanted version 1, this can go. */
1561 #define YYFAIL goto yyerrlab
1563 #define YYRECOVERING() (!!yyerrstatus)
1565 #define YYBACKUP(Token, Value) \
1567 if (yychar == YYEMPTY && yylen == 1) \
1571 yytoken = YYTRANSLATE (yychar); \
1577 yyerror ("syntax error: cannot back up");\
1584 #define YYERRCODE 256
1587 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1588 If N is 0, then set CURRENT to the empty location which ends
1589 the previous symbol: RHS[0] (always defined). */
1591 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1592 #ifndef YYLLOC_DEFAULT
1593 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1597 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1598 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1599 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1600 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1604 (Current).first_line = (Current).last_line = \
1605 YYRHSLOC (Rhs, 0).last_line; \
1606 (Current).first_column = (Current).last_column = \
1607 YYRHSLOC (Rhs, 0).last_column; \
1613 /* YY_LOCATION_PRINT -- Print the location on the stream.
1614 This macro was not mandated originally: define only if we know
1615 we won't break user code: when these are the locations we know. */
1617 #ifndef YY_LOCATION_PRINT
1618 # if YYLTYPE_IS_TRIVIAL
1619 # define YY_LOCATION_PRINT(File, Loc) \
1620 fprintf (File, "%d.%d-%d.%d", \
1621 (Loc).first_line, (Loc).first_column, \
1622 (Loc).last_line, (Loc).last_column)
1624 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1629 /* YYLEX -- calling `yylex' with the right arguments. */
1632 # define YYLEX yylex (YYLEX_PARAM)
1634 # define YYLEX yylex ()
1637 /* Enable debugging if requested. */
1641 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1642 # define YYFPRINTF fprintf
1645 # define YYDPRINTF(Args) \
1651 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1655 YYFPRINTF (stderr, "%s ", Title); \
1656 yysymprint (stderr, \
1658 YYFPRINTF (stderr, "\n"); \
1662 /*------------------------------------------------------------------.
1663 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1665 `------------------------------------------------------------------*/
1667 #if defined (__STDC__) || defined (__cplusplus)
1669 yy_stack_print (short int *bottom, short int *top)
1672 yy_stack_print (bottom, top)
1677 YYFPRINTF (stderr, "Stack now");
1678 for (/* Nothing. */; bottom <= top; ++bottom)
1679 YYFPRINTF (stderr, " %d", *bottom);
1680 YYFPRINTF (stderr, "\n");
1683 # define YY_STACK_PRINT(Bottom, Top) \
1686 yy_stack_print ((Bottom), (Top)); \
1690 /*------------------------------------------------.
1691 | Report that the YYRULE is going to be reduced. |
1692 `------------------------------------------------*/
1694 #if defined (__STDC__) || defined (__cplusplus)
1696 yy_reduce_print (int yyrule)
1699 yy_reduce_print (yyrule)
1704 unsigned int yylno = yyrline[yyrule];
1705 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
1707 /* Print the symbols being reduced, and their result. */
1708 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1709 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
1710 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
1713 # define YY_REDUCE_PRINT(Rule) \
1716 yy_reduce_print (Rule); \
1719 /* Nonzero means print parse trace. It is left uninitialized so that
1720 multiple parsers can coexist. */
1722 #else /* !YYDEBUG */
1723 # define YYDPRINTF(Args)
1724 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1725 # define YY_STACK_PRINT(Bottom, Top)
1726 # define YY_REDUCE_PRINT(Rule)
1727 #endif /* !YYDEBUG */
1730 /* YYINITDEPTH -- initial size of the parser's stacks. */
1732 # define YYINITDEPTH 200
1735 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1736 if the built-in stack extension method is used).
1738 Do not make this value too large; the results are undefined if
1739 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
1740 evaluated with infinite-precision integer arithmetic. */
1743 # define YYMAXDEPTH 10000
1751 # if defined (__GLIBC__) && defined (_STRING_H)
1752 # define yystrlen strlen
1754 /* Return the length of YYSTR. */
1756 # if defined (__STDC__) || defined (__cplusplus)
1757 yystrlen (const char *yystr)
1763 register const char *yys = yystr;
1765 while (*yys++ != '\0')
1768 return yys - yystr - 1;
1774 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1775 # define yystpcpy stpcpy
1777 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1780 # if defined (__STDC__) || defined (__cplusplus)
1781 yystpcpy (char *yydest, const char *yysrc)
1783 yystpcpy (yydest, yysrc)
1788 register char *yyd = yydest;
1789 register const char *yys = yysrc;
1791 while ((*yyd++ = *yys++) != '\0')
1799 #endif /* !YYERROR_VERBOSE */
1804 /*--------------------------------.
1805 | Print this symbol on YYOUTPUT. |
1806 `--------------------------------*/
1808 #if defined (__STDC__) || defined (__cplusplus)
1810 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1813 yysymprint (yyoutput, yytype, yyvaluep)
1819 /* Pacify ``unused variable'' warnings. */
1822 if (yytype < YYNTOKENS)
1823 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1825 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1829 if (yytype < YYNTOKENS)
1830 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1837 YYFPRINTF (yyoutput, ")");
1840 #endif /* ! YYDEBUG */
1841 /*-----------------------------------------------.
1842 | Release the memory associated to this symbol. |
1843 `-----------------------------------------------*/
1845 #if defined (__STDC__) || defined (__cplusplus)
1847 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1850 yydestruct (yymsg, yytype, yyvaluep)
1856 /* Pacify ``unused variable'' warnings. */
1861 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1872 /* Prevent warnings from -Wmissing-prototypes. */
1874 #ifdef YYPARSE_PARAM
1875 # if defined (__STDC__) || defined (__cplusplus)
1876 int yyparse (void *YYPARSE_PARAM);
1880 #else /* ! YYPARSE_PARAM */
1881 #if defined (__STDC__) || defined (__cplusplus)
1886 #endif /* ! YYPARSE_PARAM */
1890 /* The look-ahead symbol. */
1893 /* The semantic value of the look-ahead symbol. */
1896 /* Number of syntax errors so far. */
1905 #ifdef YYPARSE_PARAM
1906 # if defined (__STDC__) || defined (__cplusplus)
1907 int yyparse (void *YYPARSE_PARAM)
1909 int yyparse (YYPARSE_PARAM)
1910 void *YYPARSE_PARAM;
1912 #else /* ! YYPARSE_PARAM */
1913 #if defined (__STDC__) || defined (__cplusplus)
1924 register int yystate;
1927 /* Number of tokens to shift before error messages enabled. */
1929 /* Look-ahead token as an internal (translated) token number. */
1932 /* Three stacks and their tools:
1933 `yyss': related to states,
1934 `yyvs': related to semantic values,
1935 `yyls': related to locations.
1937 Refer to the stacks thru separate pointers, to allow yyoverflow
1938 to reallocate them elsewhere. */
1940 /* The state stack. */
1941 short int yyssa[YYINITDEPTH];
1942 short int *yyss = yyssa;
1943 register short int *yyssp;
1945 /* The semantic value stack. */
1946 YYSTYPE yyvsa[YYINITDEPTH];
1947 YYSTYPE *yyvs = yyvsa;
1948 register YYSTYPE *yyvsp;
1952 #define YYPOPSTACK (yyvsp--, yyssp--)
1954 YYSIZE_T yystacksize = YYINITDEPTH;
1956 /* The variables used to return semantic value and location from the
1961 /* When reducing, the number of symbols on the RHS of the reduced
1965 YYDPRINTF ((stderr, "Starting parse\n"));
1970 yychar = YYEMPTY; /* Cause a token to be read. */
1972 /* Initialize stack pointers.
1973 Waste one element of value and location stack
1974 so that they stay on the same level as the state stack.
1975 The wasted elements are never initialized. */
1985 /*------------------------------------------------------------.
1986 | yynewstate -- Push a new state, which is found in yystate. |
1987 `------------------------------------------------------------*/
1989 /* In all cases, when you get here, the value and location stacks
1990 have just been pushed. so pushing a state here evens the stacks.
1997 if (yyss + yystacksize - 1 <= yyssp)
1999 /* Get the current used size of the three stacks, in elements. */
2000 YYSIZE_T yysize = yyssp - yyss + 1;
2004 /* Give user a chance to reallocate the stack. Use copies of
2005 these so that the &'s don't force the real ones into
2007 YYSTYPE *yyvs1 = yyvs;
2008 short int *yyss1 = yyss;
2011 /* Each stack pointer address is followed by the size of the
2012 data in use in that stack, in bytes. This used to be a
2013 conditional around just the two extra args, but that might
2014 be undefined if yyoverflow is a macro. */
2015 yyoverflow ("parser stack overflow",
2016 &yyss1, yysize * sizeof (*yyssp),
2017 &yyvs1, yysize * sizeof (*yyvsp),
2024 #else /* no yyoverflow */
2025 # ifndef YYSTACK_RELOCATE
2028 /* Extend the stack our own way. */
2029 if (YYMAXDEPTH <= yystacksize)
2032 if (YYMAXDEPTH < yystacksize)
2033 yystacksize = YYMAXDEPTH;
2036 short int *yyss1 = yyss;
2037 union yyalloc *yyptr =
2038 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2041 YYSTACK_RELOCATE (yyss);
2042 YYSTACK_RELOCATE (yyvs);
2044 # undef YYSTACK_RELOCATE
2046 YYSTACK_FREE (yyss1);
2049 #endif /* no yyoverflow */
2051 yyssp = yyss + yysize - 1;
2052 yyvsp = yyvs + yysize - 1;
2055 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2056 (unsigned long int) yystacksize));
2058 if (yyss + yystacksize - 1 <= yyssp)
2062 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2071 /* Do appropriate processing given the current state. */
2072 /* Read a look-ahead token if we need one and don't already have one. */
2075 /* First try to decide what to do without reference to look-ahead token. */
2077 yyn = yypact[yystate];
2078 if (yyn == YYPACT_NINF)
2081 /* Not known => get a look-ahead token if don't already have one. */
2083 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2084 if (yychar == YYEMPTY)
2086 YYDPRINTF ((stderr, "Reading a token: "));
2090 if (yychar <= YYEOF)
2092 yychar = yytoken = YYEOF;
2093 YYDPRINTF ((stderr, "Now at end of input.\n"));
2097 yytoken = YYTRANSLATE (yychar);
2098 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2101 /* If the proper action on seeing token YYTOKEN is to reduce or to
2102 detect an error, take that action. */
2104 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2109 if (yyn == 0 || yyn == YYTABLE_NINF)
2118 /* Shift the look-ahead token. */
2119 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2121 /* Discard the token being shifted unless it is eof. */
2122 if (yychar != YYEOF)
2128 /* Count tokens shifted since error; after three, turn off error
2137 /*-----------------------------------------------------------.
2138 | yydefault -- do the default action for the current state. |
2139 `-----------------------------------------------------------*/
2141 yyn = yydefact[yystate];
2147 /*-----------------------------.
2148 | yyreduce -- Do a reduction. |
2149 `-----------------------------*/
2151 /* yyn is the number of a rule to reduce with. */
2154 /* If YYLEN is nonzero, implement the default value of the action:
2157 Otherwise, the following line sets YYVAL to garbage.
2158 This behavior is undocumented and Bison
2159 users should not rely upon it. Assigning to YYVAL
2160 unconditionally makes the parser a bit smaller, and it avoids a
2161 GCC warning that YYVAL may be used uninitialized. */
2162 yyval = yyvsp[1-yylen];
2165 YY_REDUCE_PRINT (yyn);
2191 Node *node = node_new (CCODE_NODE,
2193 "cbuf:steal", ((yyvsp[0].cbuf))->str,
2194 "line_no", ccode_line,
2196 nodes = g_list_append(nodes,node);
2197 g_string_free((yyvsp[0].cbuf),FALSE);
2204 Node *node = node_new (CCODE_NODE,
2206 "cbuf:steal", ((yyvsp[0].cbuf))->str,
2207 "line_no", ccode_line,
2209 nodes = g_list_append(nodes,node);
2210 g_string_free((yyvsp[0].cbuf),FALSE);
2217 Node *node = node_new (CCODE_NODE,
2219 "cbuf:steal", ((yyvsp[0].cbuf))->str,
2220 "line_no", ccode_line,
2222 nodes = g_list_append(nodes,node);
2223 g_string_free((yyvsp[0].cbuf),FALSE);
2230 Node *node = node_new (CCODE_NODE,
2232 "cbuf:steal", ((yyvsp[0].cbuf))->str,
2233 "line_no", ccode_line,
2235 nodes = g_list_append(nodes,node);
2236 g_string_free((yyvsp[0].cbuf),FALSE);
2243 Node *node = node_new (CCODE_NODE,
2245 "cbuf:steal", ((yyvsp[0].cbuf))->str,
2246 "line_no", ccode_line,
2248 nodes = g_list_append(nodes,node);
2249 g_string_free((yyvsp[0].cbuf),FALSE);
2256 Node *node = node_new (CCODE_NODE,
2258 "cbuf:steal", ((yyvsp[0].cbuf))->str,
2259 "line_no", ccode_line,
2261 nodes = g_list_append(nodes,node);
2262 g_string_free((yyvsp[0].cbuf),FALSE);
2309 ((Class *)class)->nodes = class_nodes;
2311 nodes = g_list_append(nodes,class);
2318 ((Class *)class)->nodes = NULL;
2320 nodes = g_list_append(nodes,class);
2327 class = node_new (CLASS_NODE,
2328 "otype:steal", (yyvsp[-3].id),
2329 "ptype:steal", (yyvsp[-1].id),
2330 "bonobo_object_class:steal", bonobo_object_class,
2331 "glade_xml", glade_xml,
2332 "interfaces:steal", interfaces,
2333 "chunk_size:steal", chunk_size,
2334 "abstract", abstract,
2336 bonobo_object_class = NULL;
2346 if(strcmp((yyvsp[-2].id),"abstract") == 0) {
2349 yyerror(_("parse error"));
2358 if(strcmp((yyvsp[-3].id),"chunks") == 0) {
2359 g_free (chunk_size);
2360 chunk_size = g_strdup((yyvsp[-2].id));
2361 } else if(strcmp((yyvsp[-3].id),"BonoboObject") == 0) {
2362 g_free (bonobo_object_class);
2363 bonobo_object_class = g_strdup((yyvsp[-2].id));
2365 yyerror(_("parse error"));
2374 if (strcmp ((yyvsp[-3].id), "interface") == 0) {
2375 interfaces = g_list_append (interfaces,
2376 g_strdup ((yyvsp[-2].id)));
2378 yyerror(_("parse error"));
2387 if(strcmp((yyvsp[-3].id),"chunks") == 0) {
2388 g_free (chunk_size);
2389 if(atoi((yyvsp[-2].id)) != 0)
2390 chunk_size = g_strdup((yyvsp[-2].id));
2394 yyerror(_("parse error"));
2403 if (strcmp ((yyvsp[-4].id), "GladeXML") == 0) {
2405 add_construct_glade((yyvsp[-3].id), (yyvsp[-2].id), NULL);
2407 yyerror(_("parse error"));
2416 if (strcmp ((yyvsp[-5].id), "GladeXML") == 0) {
2418 add_construct_glade((yyvsp[-4].id), (yyvsp[-3].id), (yyvsp[-2].id));
2420 yyerror(_("parse error"));
2429 if (strcmp ((yyvsp[-4].id), "GladeXML") == 0) {
2431 add_construct_glade((yyvsp[-3].id), (yyvsp[-2].id), NULL);
2433 yyerror(_("parse error"));
2442 if (strcmp ((yyvsp[-5].id), "GladeXML") == 0) {
2444 add_construct_glade((yyvsp[-4].id), (yyvsp[-3].id), (yyvsp[-2].id));
2446 yyerror(_("parse error"));
2470 if (strcmp ((yyvsp[-1].id), "BonoboObject") != 0) {
2471 g_free ((yyvsp[-1].id));
2472 yyerror (_("parse error"));
2475 g_free ((yyvsp[-1].id));
2476 last_added_method->bonobo_object_func = TRUE;
2483 if (strcmp ((yyvsp[-2].id), "interface") != 0) {
2484 g_free ((yyvsp[-2].id));
2485 g_free ((yyvsp[-1].id));
2486 yyerror (_("parse error"));
2489 g_free ((yyvsp[-2].id));
2490 node_set ((Node *)last_added_method,
2491 "interface:steal", (yyvsp[-1].id),
2518 { the_scope = PUBLIC_SCOPE; }
2523 { the_scope = PRIVATE_SCOPE; }
2528 { the_scope = PROTECTED_SCOPE; }
2533 { the_scope = CLASS_SCOPE; }
2539 if (strcmp ((yyvsp[-1].id), "destroywith") == 0) {
2540 g_free ((yyvsp[-1].id));
2541 destructor_unref = FALSE;
2542 destructor = (yyvsp[0].id);
2543 destructor_line = line_no;
2544 destructor_simple = TRUE;
2545 } else if (strcmp ((yyvsp[-1].id), "unrefwith") == 0) {
2546 g_free ((yyvsp[-1].id));
2547 destructor_unref = TRUE;
2548 destructor = (yyvsp[0].id);
2549 destructor_line = line_no;
2550 destructor_simple = TRUE;
2552 g_free ((yyvsp[-1].id));
2553 g_free ((yyvsp[0].id));
2554 yyerror (_("parse error"));
2563 if (strcmp ((yyvsp[-2].id), "destroy") == 0) {
2564 g_free((yyvsp[-2].id));
2565 destructor_unref = FALSE;
2566 destructor = ((yyvsp[0].cbuf))->str;
2567 g_string_free((yyvsp[0].cbuf), FALSE);
2568 destructor_line = ccode_line;
2569 destructor_simple = FALSE;
2570 } else if (strcmp ((yyvsp[-2].id), "unref") == 0) {
2571 g_free ((yyvsp[-2].id));
2572 destructor_unref = TRUE;
2573 destructor = ((yyvsp[0].cbuf))->str;
2574 g_string_free ((yyvsp[0].cbuf), FALSE);
2575 destructor_line = ccode_line;
2576 destructor_simple = FALSE;
2578 g_free ((yyvsp[-2].id));
2579 g_string_free ((yyvsp[0].cbuf), TRUE);
2580 yyerror (_("parse error"));
2589 initializer = (yyvsp[0].id);
2590 initializer_line = ccode_line;
2597 initializer = ((yyvsp[0].cbuf))->str;
2598 initializer_line = ccode_line;
2599 g_string_free((yyvsp[0].cbuf), FALSE);
2615 { destructor = NULL; }
2620 { initializer = NULL; }
2626 if (strcmp ((yyvsp[0].id), "GladeXML") == 0) {
2627 glade_widget = TRUE;
2629 yyerror(_("parse error"));
2646 push_variable((yyvsp[-2].id), the_scope,(yyvsp[-4].line), NULL);
2653 push_variable((yyvsp[-3].id), the_scope, (yyvsp[-5].line), (yyvsp[-2].id));
2661 if(strcmp((yyvsp[-6].id),"get")==0 &&
2662 strcmp((yyvsp[-3].id),"set")==0) {
2663 Type *type = pop_type();
2664 g_free ((yyvsp[-6].id));
2665 g_free ((yyvsp[-3].id));
2666 node = node_new (ARGUMENT_NODE,
2667 "gtktype:steal", (yyvsp[-9].id),
2668 "atype:steal", type,
2669 "flags:steal", (yyvsp[-10].list),
2670 "name:steal", (yyvsp[-8].id),
2671 "get:steal", ((yyvsp[-4].cbuf))->str,
2672 "get_line", (yyvsp[-5].line),
2673 "set:steal", ((yyvsp[-1].cbuf))->str,
2674 "set_line", (yyvsp[-2].line),
2675 "line_no", (yyvsp[-11].line),
2678 class_nodes = g_list_append(class_nodes,node);
2680 g_string_free ((yyvsp[-4].cbuf), FALSE);
2681 g_string_free ((yyvsp[-1].cbuf), FALSE);
2683 } else if(strcmp((yyvsp[-6].id),"set")==0 &&
2684 strcmp((yyvsp[-3].id),"get")==0) {
2685 Type *type = pop_type();
2686 g_free ((yyvsp[-6].id));
2687 g_free ((yyvsp[-3].id));
2688 node = node_new (ARGUMENT_NODE,
2689 "gtktype:steal", (yyvsp[-9].id),
2690 "atype:steal", type,
2691 "flags:steal", (yyvsp[-10].list),
2692 "name:steal", (yyvsp[-8].id),
2693 "get:steal", ((yyvsp[-1].cbuf))->str,
2694 "get_line", (yyvsp[-2].line),
2695 "set:steal", ((yyvsp[-4].cbuf))->str,
2696 "set_line", (yyvsp[-5].line),
2697 "line_no", (yyvsp[-11].line),
2699 g_string_free ((yyvsp[-1].cbuf), FALSE);
2700 g_string_free ((yyvsp[-4].cbuf), FALSE);
2701 class_nodes = g_list_append(class_nodes,node);
2703 g_free ((yyvsp[-9].id));
2704 g_free ((yyvsp[-8].id));
2705 g_free ((yyvsp[-6].id));
2706 g_free ((yyvsp[-3].id));
2707 g_list_foreach ((yyvsp[-10].list), (GFunc)g_free, NULL);
2708 g_list_free ((yyvsp[-10].list));
2709 g_string_free ((yyvsp[-1].cbuf), TRUE);
2710 g_string_free ((yyvsp[-4].cbuf), TRUE);
2711 yyerror (_("parse error"));
2715 if ((yyvsp[-7].id) != NULL) {
2716 Argument *arg = (Argument *)node;
2717 export_accessors (arg->name,
2718 arg->get != NULL, arg->get_line,
2719 arg->set != NULL, arg->set_line,
2723 g_free ((yyvsp[-7].id));
2730 #line 1058 "parse.y"
2733 if(strcmp((yyvsp[-3].id), "get") == 0) {
2734 Type *type = pop_type();
2735 g_free ((yyvsp[-3].id));
2736 node = node_new (ARGUMENT_NODE,
2737 "gtktype:steal", (yyvsp[-6].id),
2738 "atype:steal", type,
2739 "flags:steal", (yyvsp[-7].list),
2740 "name:steal", (yyvsp[-5].id),
2741 "get:steal", ((yyvsp[-1].cbuf))->str,
2742 "get_line", (yyvsp[-2].line),
2743 "line_no", (yyvsp[-8].line),
2746 g_string_free ((yyvsp[-1].cbuf), FALSE);
2747 class_nodes = g_list_append(class_nodes, node);
2748 } else if(strcmp((yyvsp[-3].id), "set") == 0) {
2749 Type *type = pop_type();
2750 g_free ((yyvsp[-3].id));
2751 node = node_new (ARGUMENT_NODE,
2752 "gtktype:steal", (yyvsp[-6].id),
2753 "atype:steal", type,
2754 "flags:steal", (yyvsp[-7].list),
2755 "name:steal", (yyvsp[-5].id),
2756 "set:steal", ((yyvsp[-1].cbuf))->str,
2757 "set_line", (yyvsp[-2].line),
2758 "line_no", (yyvsp[-8].line),
2761 g_string_free ((yyvsp[-1].cbuf), FALSE);
2762 class_nodes = g_list_append (class_nodes, node);
2764 g_free ((yyvsp[-3].id));
2765 g_free ((yyvsp[-6].id));
2766 g_free ((yyvsp[-5].id));
2767 g_list_foreach ((yyvsp[-7].list), (GFunc)g_free, NULL);
2768 g_list_free ((yyvsp[-7].list));
2769 g_string_free ((yyvsp[-1].cbuf), TRUE);
2770 yyerror(_("parse error"));
2774 if ((yyvsp[-4].id) != NULL) {
2775 Argument *arg = (Argument *)node;
2776 export_accessors (arg->name,
2777 arg->get != NULL, arg->get_line,
2778 arg->set != NULL, arg->set_line,
2782 g_free ((yyvsp[-4].id));
2788 #line 1112 "parse.y"
2791 char *get, *set = NULL;
2796 if(strcmp((yyvsp[0].id), "link")!=0 &&
2797 strcmp((yyvsp[0].id), "stringlink")!=0 &&
2798 strcmp((yyvsp[0].id), "objectlink")!=0) {
2799 g_free((yyvsp[0].id));
2800 g_free((yyvsp[-3].id));
2801 g_free((yyvsp[-2].id));
2802 g_list_foreach((yyvsp[-4].list),(GFunc)g_free,NULL);
2803 g_list_free((yyvsp[-4].list));
2804 yyerror(_("parse error"));
2810 var = find_var_or_die((yyvsp[-2].id), (yyvsp[-5].line));
2811 if(var->scope == PRIVATE_SCOPE) {
2812 root = "self->_priv";
2813 } else if(var->scope == CLASS_SCOPE) {
2814 root = "SELF_GET_CLASS(self)";
2816 error_print(GOB_ERROR, (yyvsp[-5].line),
2817 _("Self aliases needed when autolinking to a classwide member"));
2822 if(strcmp((yyvsp[0].id), "link")==0) {
2823 set = g_strdup_printf("%s->%s = ARG;",
2824 root, (yyvsp[-2].id));
2825 } else if(strcmp((yyvsp[0].id), "stringlink")==0) {
2826 set = g_strdup_printf("g_free (%s->%s); "
2827 "%s->%s = g_strdup (ARG);",
2828 root, (yyvsp[-2].id),
2829 root, (yyvsp[-2].id));
2830 } else if(strcmp((yyvsp[0].id), "objectlink")==0) {
2831 set = g_strdup_printf(
2833 "g_object_ref (G_OBJECT (ARG)); "
2834 "if (%s->%s != NULL) "
2835 "g_object_unref (G_OBJECT (%s->%s)); "
2837 root, (yyvsp[-2].id),
2838 root, (yyvsp[-2].id),
2839 root, (yyvsp[-2].id));
2841 g_assert_not_reached();
2844 get = g_strdup_printf("ARG = %s->%s;", root, (yyvsp[-2].id));
2846 g_free ((yyvsp[0].id));
2849 type = (Type *)node_copy ((Node *)var->vtype);
2851 node = node_new (ARGUMENT_NODE,
2852 "gtktype:steal", (yyvsp[-3].id),
2853 "atype:steal", type,
2854 "flags:steal", (yyvsp[-4].list),
2855 "name:steal", (yyvsp[-2].id),
2857 "get_line", (yyvsp[-5].line),
2859 "set_line", (yyvsp[-5].line),
2860 "line_no", (yyvsp[-5].line),
2863 if ((yyvsp[-1].id) != NULL) {
2864 Argument *arg = (Argument *)node;
2865 export_accessors (arg->name,
2866 arg->get != NULL, arg->get_line,
2867 arg->set != NULL, arg->set_line,
2871 g_free ((yyvsp[-1].id));
2874 class_nodes = g_list_append (class_nodes, node);
2879 #line 1201 "parse.y"
2881 if (strcmp ((yyvsp[-1].id), "export")!=0) {
2882 g_free ((yyvsp[-1].id));
2883 yyerror (_("parse error"));
2886 (yyval.id) = (yyvsp[-1].id);
2891 #line 1209 "parse.y"
2898 #line 1214 "parse.y"
2901 node_set ((Node *)property,
2902 "line_no", (yyvsp[-10].line),
2903 "gtktype:steal", debool ((yyvsp[-9].id)),
2904 "name:steal", (yyvsp[-8].id),
2906 if (strcmp ((yyvsp[-6].id), "get") == 0 &&
2907 strcmp ((yyvsp[-3].id), "set") == 0) {
2908 node_set ((Node *)property,
2909 "get:steal", ((yyvsp[-4].cbuf))->str,
2910 "get_line", (yyvsp[-5].line),
2911 "set:steal", ((yyvsp[-1].cbuf))->str,
2912 "set_line", (yyvsp[-2].line),
2914 g_string_free ((yyvsp[-4].cbuf), FALSE);
2915 g_string_free ((yyvsp[-1].cbuf), FALSE);
2916 g_free ((yyvsp[-6].id));
2917 g_free ((yyvsp[-3].id));
2918 } else if (strcmp ((yyvsp[-6].id), "set") == 0 &&
2919 strcmp ((yyvsp[-3].id), "get") == 0) {
2920 node_set ((Node *)property,
2921 "get:steal", ((yyvsp[-1].cbuf))->str,
2922 "get_line", (yyvsp[-2].line),
2923 "set:steal", ((yyvsp[-4].cbuf))->str,
2924 "set_line", (yyvsp[-5].line),
2926 g_string_free ((yyvsp[-4].cbuf), FALSE);
2927 g_string_free ((yyvsp[-1].cbuf), FALSE);
2928 g_free ((yyvsp[-6].id));
2929 g_free ((yyvsp[-3].id));
2931 g_string_free ((yyvsp[-4].cbuf), TRUE);
2932 g_string_free ((yyvsp[-1].cbuf), TRUE);
2933 g_free ((yyvsp[-6].id));
2934 g_free ((yyvsp[-3].id));
2935 node_free ((Node *)property);
2937 yyerror (_("parse error"));
2940 property_link_and_export ((Node *)property);
2941 if (property != NULL) {
2942 class_nodes = g_list_append (class_nodes,
2950 #line 1262 "parse.y"
2953 node_set ((Node *)property,
2954 "line_no", (yyvsp[-7].line),
2955 "gtktype:steal", debool ((yyvsp[-6].id)),
2956 "name:steal", (yyvsp[-5].id),
2958 if (strcmp ((yyvsp[-3].id), "get") == 0) {
2959 node_set ((Node *)property,
2960 "get:steal", ((yyvsp[-1].cbuf))->str,
2961 "get_line", (yyvsp[-2].line),
2963 g_string_free ((yyvsp[-1].cbuf), FALSE);
2964 g_free ((yyvsp[-3].id));
2965 } else if (strcmp ((yyvsp[-3].id), "set") == 0) {
2966 node_set ((Node *)property,
2967 "set:steal", ((yyvsp[-1].cbuf))->str,
2968 "set_line", (yyvsp[-2].line),
2970 g_string_free ((yyvsp[-1].cbuf), FALSE);
2971 g_free ((yyvsp[-3].id));
2973 g_string_free ((yyvsp[-1].cbuf), TRUE);
2974 g_free ((yyvsp[-3].id));
2975 node_free ((Node *)property);
2977 yyerror (_("parse error"));
2980 property_link_and_export ((Node *)property);
2981 if (property != NULL) {
2982 class_nodes = g_list_append (class_nodes,
2990 #line 1298 "parse.y"
2993 node_set ((Node *)property,
2994 "line_no", (yyvsp[-4].line),
2995 "gtktype:steal", debool ((yyvsp[-3].id)),
2996 "name:steal", (yyvsp[-2].id),
2998 property_link_and_export ((Node *)property);
2999 if (property != NULL) {
3000 class_nodes = g_list_append (class_nodes,
3008 #line 1314 "parse.y"
3013 #line 1315 "parse.y"
3018 #line 1318 "parse.y"
3023 #line 1319 "parse.y"
3028 #line 1322 "parse.y"
3029 { (yyval.id) = (yyvsp[0].id); }
3033 #line 1323 "parse.y"
3035 if (strcmp ((yyvsp[-3].id), "_") != 0) {
3036 g_free ((yyvsp[-3].id));
3037 yyerror(_("parse error"));
3040 g_free ((yyvsp[-3].id));
3041 (yyval.id) = g_strconcat ("_(", (yyvsp[-1].id), ")", NULL);
3042 g_free ((yyvsp[-1].id));
3047 #line 1335 "parse.y"
3048 { (yyval.id) = (yyvsp[0].id); }
3052 #line 1336 "parse.y"
3053 { (yyval.id) = (yyvsp[0].id); }
3057 #line 1339 "parse.y"
3060 node_set ((Node *)property,
3061 "nick:steal", (yyvsp[0].id),
3067 #line 1345 "parse.y"
3070 node_set ((Node *)property,
3071 "blurb:steal", (yyvsp[0].id),
3077 #line 1351 "parse.y"
3080 node_set ((Node *)property,
3081 "maximum:steal", (yyvsp[0].id),
3087 #line 1357 "parse.y"
3090 node_set ((Node *)property,
3091 "minimum:steal", (yyvsp[0].id),
3097 #line 1363 "parse.y"
3100 node_set ((Node *)property,
3101 "default_value:steal", (yyvsp[0].id),
3107 #line 1369 "parse.y"
3110 node_set ((Node *)property,
3111 "flags:steal", (yyvsp[0].list),
3117 #line 1375 "parse.y"
3119 Type *type = pop_type ();
3121 node_set ((Node *)property,
3122 "ptype:steal", type,
3128 #line 1382 "parse.y"
3131 node_set ((Node *)property,
3132 "extra_gtktype:steal", (yyvsp[0].id),
3138 #line 1388 "parse.y"
3141 node_set ((Node *)property,
3142 "extra_gtktype:steal", (yyvsp[0].id),
3148 #line 1394 "parse.y"
3151 node_set ((Node *)property,
3152 "extra_gtktype:steal", (yyvsp[0].id),
3158 #line 1400 "parse.y"
3161 node_set ((Node *)property,
3162 "extra_gtktype:steal", (yyvsp[0].id),
3168 #line 1406 "parse.y"
3171 node_set ((Node *)property,
3172 "extra_gtktype:steal", (yyvsp[0].id),
3178 #line 1412 "parse.y"
3181 node_set ((Node *)property,
3182 "extra_gtktype:steal", (yyvsp[0].id),
3188 #line 1418 "parse.y"
3191 node_set ((Node *)property,
3192 "extra_gtktype:steal", (yyvsp[0].id),
3198 #line 1424 "parse.y"
3201 node_set ((Node *)property,
3202 "extra_gtktype:steal", (yyvsp[0].id),
3208 #line 1430 "parse.y"
3211 node_set ((Node *)property,
3212 "extra_gtktype:steal", (yyvsp[0].id),
3218 #line 1436 "parse.y"
3221 node_set ((Node *)property,
3222 "extra_gtktype:steal", (yyvsp[0].id),
3228 #line 1442 "parse.y"
3231 if (strcmp ((yyvsp[0].id), "override") == 0) {
3232 g_free((yyvsp[0].id));
3233 node_set ((Node *)property,
3236 } else if (strcmp ((yyvsp[0].id), "link") == 0) {
3237 g_free((yyvsp[0].id));
3238 node_set ((Node *)property,
3241 } else if (strcmp ((yyvsp[0].id), "export") == 0) {
3242 g_free((yyvsp[0].id));
3243 node_set ((Node *)property,
3247 g_free((yyvsp[0].id));
3248 yyerror(_("parse error"));
3255 #line 1467 "parse.y"
3257 if(strcmp((yyvsp[-2].id),"type")!=0) {
3258 g_free((yyvsp[-4].id));
3259 g_free((yyvsp[-2].id));
3260 yyerror(_("parse error"));
3263 (yyval.id) = debool ((yyvsp[-4].id));
3268 #line 1476 "parse.y"
3270 (yyval.id) = debool ((yyvsp[0].id));
3271 typestack = g_list_prepend(typestack,NULL);
3276 #line 1482 "parse.y"
3277 { (yyval.list) = (yyvsp[-1].list); }
3281 #line 1483 "parse.y"
3282 { (yyval.list) = NULL; }
3286 #line 1486 "parse.y"
3288 (yyval.list) = g_list_append((yyvsp[0].list),(yyvsp[-2].id));
3293 #line 1489 "parse.y"
3295 (yyval.list) = g_list_append(NULL,(yyvsp[0].id));
3300 #line 1495 "parse.y"
3302 Node *node = node_new (TYPE_NODE,
3303 "name:steal", (yyvsp[-1].id),
3304 "pointer:steal", (yyvsp[0].id),
3306 typestack = g_list_prepend(typestack,node);
3311 #line 1502 "parse.y"
3313 Node *node = node_new (TYPE_NODE,
3314 "name:steal", (yyvsp[0].id),
3316 typestack = g_list_prepend(typestack,node);
3321 #line 1511 "parse.y"
3323 (yyval.id) = (yyvsp[0].id);
3328 #line 1514 "parse.y"
3330 (yyval.id) = (yyvsp[0].id);
3335 #line 1517 "parse.y"
3337 (yyval.id) = g_strconcat("const ", (yyvsp[0].id), NULL);
3338 g_free((yyvsp[0].id));
3343 #line 1521 "parse.y"
3345 (yyval.id) = g_strconcat((yyvsp[-1].id), " const", NULL);
3346 g_free((yyvsp[-1].id));
3351 #line 1525 "parse.y"
3353 (yyval.id) = g_strconcat((yyvsp[-1].id), " ", (yyvsp[0].id), NULL);
3354 g_free((yyvsp[0].id));
3359 #line 1529 "parse.y"
3361 (yyval.id) = g_strconcat("const ", (yyvsp[-1].id), " ",
3362 (yyvsp[0].id), NULL);
3363 g_free((yyvsp[0].id));
3368 #line 1534 "parse.y"
3370 (yyval.id) = g_strconcat((yyvsp[-2].id), " ",
3371 (yyvsp[-1].id), " const", NULL);
3372 g_free((yyvsp[-1].id));
3377 #line 1542 "parse.y"
3379 (yyval.id) = g_strconcat((yyvsp[-1].id), " ", (yyvsp[0].id), NULL);
3380 g_free((yyvsp[0].id));
3385 #line 1546 "parse.y"
3387 (yyval.id) = g_strconcat((yyvsp[-1].id), " ", (yyvsp[0].id), NULL);
3388 g_free((yyvsp[-1].id));
3389 g_free((yyvsp[0].id));
3394 #line 1551 "parse.y"
3396 (yyval.id) = g_strconcat("const ", (yyvsp[0].id), NULL);
3397 g_free((yyvsp[0].id));
3402 #line 1555 "parse.y"
3404 (yyval.id) = (yyvsp[0].id);
3409 #line 1558 "parse.y"
3411 (yyval.id) = g_strconcat((yyvsp[-1].id), " const", NULL);
3412 g_free((yyvsp[-1].id));
3417 #line 1562 "parse.y"
3419 (yyval.id) = g_strdup((yyvsp[0].id));
3424 #line 1565 "parse.y"
3426 (yyval.id) = g_strconcat((yyvsp[-1].id), " const", NULL);
3431 #line 1570 "parse.y"
3432 { (yyval.id) = "void"; }
3436 #line 1571 "parse.y"
3437 { (yyval.id) = "char"; }
3441 #line 1572 "parse.y"
3442 { (yyval.id) = "short"; }
3446 #line 1573 "parse.y"
3447 { (yyval.id) = "int"; }
3451 #line 1574 "parse.y"
3452 { (yyval.id) = "long"; }
3456 #line 1575 "parse.y"
3457 { (yyval.id) = "float"; }
3461 #line 1576 "parse.y"
3462 { (yyval.id) = "double"; }
3466 #line 1577 "parse.y"
3467 { (yyval.id) = "signed"; }
3471 #line 1578 "parse.y"
3472 { (yyval.id) = "unsigned"; }
3476 #line 1581 "parse.y"
3477 { (yyval.id) = "struct"; }
3481 #line 1582 "parse.y"
3482 { (yyval.id) = "union"; }
3486 #line 1583 "parse.y"
3487 { (yyval.id) = "enum"; }
3491 #line 1586 "parse.y"
3492 { (yyval.id) = g_strdup("*"); }
3496 #line 1587 "parse.y"
3497 { (yyval.id) = g_strdup("* const"); }
3501 #line 1588 "parse.y"
3503 (yyval.id) = g_strconcat("*", (yyvsp[0].id), NULL);
3504 g_free((yyvsp[0].id));
3509 #line 1592 "parse.y"
3511 (yyval.id) = g_strconcat("* const", (yyvsp[0].id), NULL);
3512 g_free((yyvsp[0].id));
3517 #line 1599 "parse.y"
3519 if(strcmp((yyvsp[-1].id), "first")==0)
3520 (yyval.sigtype) = SIGNAL_FIRST_METHOD;
3521 else if(strcmp((yyvsp[-1].id), "last")==0)
3522 (yyval.sigtype) = SIGNAL_LAST_METHOD;
3524 yyerror(_("signal must be 'first' or 'last'"));
3525 g_free((yyvsp[-1].id));
3528 g_free((yyvsp[-1].id));
3533 #line 1611 "parse.y"
3535 (yyval.sigtype) = SIGNAL_LAST_METHOD;
3540 #line 1617 "parse.y"
3542 if(strcmp((yyvsp[-1].id),"first")==0)
3543 (yyval.sigtype) = SIGNAL_FIRST_METHOD;
3544 else if(strcmp((yyvsp[-1].id),"last")==0)
3545 (yyval.sigtype) = SIGNAL_LAST_METHOD;
3547 yyerror(_("signal must be 'first' or 'last'"));
3548 g_free((yyvsp[-1].id));
3551 g_free((yyvsp[-1].id));
3556 #line 1629 "parse.y"
3558 if(strcmp((yyvsp[-2].id),"first")==0)
3559 (yyval.sigtype) = SIGNAL_FIRST_METHOD;
3560 else if(strcmp((yyvsp[-2].id),"last")==0)
3561 (yyval.sigtype) = SIGNAL_LAST_METHOD;
3563 yyerror(_("signal must be 'first' or 'last'"));
3564 g_free((yyvsp[-2].id));
3567 g_free((yyvsp[-2].id));
3572 #line 1641 "parse.y"
3574 (yyval.sigtype) = SIGNAL_LAST_METHOD;
3579 #line 1644 "parse.y"
3581 /* the_scope was default thus public */
3582 the_scope = PUBLIC_SCOPE;
3587 #line 1650 "parse.y"
3589 gtktypes = g_list_prepend(gtktypes, debool ((yyvsp[-3].id)));
3594 #line 1655 "parse.y"
3596 gtktypes = g_list_append(gtktypes, debool ((yyvsp[0].id)));
3601 #line 1658 "parse.y"
3603 gtktypes = g_list_append(gtktypes, debool ((yyvsp[0].id)));
3608 #line 1663 "parse.y"
3609 { (yyval.cbuf) = (yyvsp[0].cbuf); }
3613 #line 1664 "parse.y"
3614 { (yyval.cbuf) = NULL; }
3618 #line 1668 "parse.y"
3621 yyerror(_("signal without 'self' as "
3622 "first parameter"));
3623 free_all_global_state();
3626 if(the_scope == CLASS_SCOPE) {
3627 yyerror(_("a method cannot be of class scope"));
3628 free_all_global_state();
3631 push_function(the_scope, (yyvsp[-7].sigtype),NULL,
3632 (yyvsp[-5].id), (yyvsp[0].cbuf),(yyvsp[-9].line),
3633 ccode_line, vararg, (yyvsp[-8].list));
3638 #line 1684 "parse.y"
3641 yyerror(_("signal without 'self' as "
3642 "first parameter"));
3643 free_all_global_state();
3646 if(the_scope == CLASS_SCOPE) {
3647 yyerror(_("a method cannot be of class scope"));
3648 free_all_global_state();
3651 push_function(the_scope, (yyvsp[-7].sigtype), NULL,
3652 (yyvsp[-5].id), (yyvsp[0].cbuf), (yyvsp[-9].line),
3653 ccode_line, vararg, (yyvsp[-8].list));
3658 #line 1700 "parse.y"
3661 yyerror(_("virtual method without 'self' as "
3662 "first parameter"));
3663 free_all_global_state();
3666 if(the_scope == CLASS_SCOPE) {
3667 yyerror(_("a method cannot be of class scope"));
3668 free_all_global_state();
3671 push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[-5].id),
3672 (yyvsp[0].cbuf), (yyvsp[-8].line),
3673 ccode_line, vararg, NULL);
3678 #line 1716 "parse.y"
3681 yyerror(_("virtual method without 'self' as "
3682 "first parameter"));
3683 free_all_global_state();
3686 if(the_scope == CLASS_SCOPE) {
3687 yyerror(_("a method cannot be of class scope"));
3688 free_all_global_state();
3691 push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[-5].id),
3692 (yyvsp[0].cbuf), (yyvsp[-7].line),
3693 ccode_line, vararg, NULL);
3698 #line 1732 "parse.y"
3701 yyerror(_("virtual method without 'self' as "
3702 "first parameter"));
3703 free_all_global_state();
3706 push_function(PUBLIC_SCOPE, VIRTUAL_METHOD, NULL,
3707 (yyvsp[-5].id), (yyvsp[0].cbuf), (yyvsp[-7].line),
3708 ccode_line, vararg, NULL);
3713 #line 1743 "parse.y"
3715 push_function(NO_SCOPE, OVERRIDE_METHOD, (yyvsp[-8].id),
3716 (yyvsp[-5].id), (yyvsp[0].cbuf),
3717 (yyvsp[-10].line), ccode_line,
3723 #line 1749 "parse.y"
3725 if(the_scope == CLASS_SCOPE) {
3726 yyerror(_("a method cannot be of class scope"));
3727 free_all_global_state();
3730 push_function(the_scope, REGULAR_METHOD, NULL, (yyvsp[-5].id),
3731 (yyvsp[0].cbuf), (yyvsp[-7].line), ccode_line,
3737 #line 1759 "parse.y"
3739 if(strcmp((yyvsp[-4].id), "init")==0) {
3740 push_init_arg((yyvsp[-2].id),FALSE);
3741 push_function(NO_SCOPE, INIT_METHOD, NULL,
3742 (yyvsp[-4].id), (yyvsp[0].cbuf), (yyvsp[-3].line),
3743 ccode_line, FALSE, NULL);
3744 } else if(strcmp((yyvsp[-4].id), "class_init")==0) {
3745 push_init_arg((yyvsp[-2].id),TRUE);
3746 push_function(NO_SCOPE, CLASS_INIT_METHOD, NULL,
3747 (yyvsp[-4].id), (yyvsp[0].cbuf), (yyvsp[-3].line),
3748 ccode_line, FALSE, NULL);
3750 g_free((yyvsp[-4].id));
3751 g_free((yyvsp[-2].id));
3752 g_string_free((yyvsp[0].cbuf),TRUE);
3753 yyerror(_("parse error "
3754 "(untyped blocks must be init or "
3762 #line 1782 "parse.y"
3764 g_free(onerror); onerror = NULL;
3765 g_free(defreturn); defreturn = NULL;
3766 if(!set_return_value((yyvsp[-1].id), (yyvsp[0].id))) {
3767 g_free((yyvsp[-1].id));
3768 g_free((yyvsp[0].id));
3769 yyerror(_("parse error"));
3772 g_free((yyvsp[-1].id));
3777 #line 1793 "parse.y"
3779 g_free(onerror); onerror = NULL;
3780 g_free(defreturn); defreturn = NULL;
3781 if(!set_return_value((yyvsp[-3].id), (yyvsp[-2].id))) {
3782 g_free((yyvsp[-3].id)); g_free((yyvsp[-2].id));
3783 g_free((yyvsp[-1].id)); g_free((yyvsp[0].id));
3784 yyerror(_("parse error"));
3787 if(!set_return_value((yyvsp[-1].id), (yyvsp[0].id))) {
3788 onerror = defreturn = NULL;
3789 g_free((yyvsp[-3].id)); g_free((yyvsp[-2].id));
3790 g_free((yyvsp[-1].id)); g_free((yyvsp[0].id));
3791 yyerror(_("parse error"));
3794 g_free((yyvsp[-3].id));
3795 g_free((yyvsp[-1].id));
3800 #line 1812 "parse.y"
3802 g_free(onerror); onerror = NULL;
3803 g_free(defreturn); defreturn = NULL;
3808 #line 1818 "parse.y"
3809 { (yyval.id) = (yyvsp[0].id); }
3813 #line 1819 "parse.y"
3815 (yyval.id) = ((yyvsp[0].cbuf))->str;
3816 g_string_free((yyvsp[0].cbuf), FALSE);
3821 #line 1825 "parse.y"
3822 { vararg = FALSE; has_self = FALSE; }
3826 #line 1826 "parse.y"
3830 if(strcmp((yyvsp[0].id),"self")==0)
3831 push_self((yyvsp[0].id), FALSE);
3833 g_free((yyvsp[0].id));
3834 yyerror(_("parse error"));
3841 #line 1837 "parse.y"
3845 if(strcmp((yyvsp[-1].id),"self")==0)
3846 push_self((yyvsp[-1].id), TRUE);
3848 g_free((yyvsp[-1].id));
3849 yyerror(_("parse error"));
3856 #line 1848 "parse.y"
3860 if(strcmp((yyvsp[0].id),"self")==0)
3861 push_self((yyvsp[0].id), TRUE);
3863 g_free((yyvsp[0].id));
3864 yyerror(_("parse error"));
3871 #line 1859 "parse.y"
3874 if(strcmp((yyvsp[-2].id),"self")==0)
3875 push_self((yyvsp[-2].id), FALSE);
3877 g_free((yyvsp[-2].id));
3878 yyerror(_("parse error"));
3885 #line 1869 "parse.y"
3888 if(strcmp((yyvsp[-3].id),"self")==0)
3889 push_self((yyvsp[-3].id), TRUE);
3891 g_free((yyvsp[-3].id));
3892 yyerror(_("parse error"));
3899 #line 1879 "parse.y"
3902 if(strcmp((yyvsp[-2].id),"self")==0)
3903 push_self((yyvsp[-2].id), TRUE);
3905 g_free((yyvsp[-2].id));
3906 yyerror(_("parse error"));
3913 #line 1889 "parse.y"
3914 { has_self = FALSE; }
3918 #line 1892 "parse.y"
3923 #line 1893 "parse.y"
3928 #line 1896 "parse.y"
3933 #line 1897 "parse.y"
3938 #line 1900 "parse.y"
3940 push_funcarg((yyvsp[0].id),NULL);
3945 #line 1903 "parse.y"
3947 push_funcarg((yyvsp[-1].id),(yyvsp[0].id));
3952 #line 1906 "parse.y"
3954 if(strcmp((yyvsp[-2].id),"check")!=0) {
3955 yyerror(_("parse error"));
3958 g_free((yyvsp[-2].id));
3959 push_funcarg((yyvsp[-4].id),NULL);
3964 #line 1914 "parse.y"
3966 if(strcmp((yyvsp[-2].id),"check")!=0) {
3967 yyerror(_("parse error"));
3970 g_free((yyvsp[-2].id));
3971 push_funcarg((yyvsp[-5].id),(yyvsp[-4].id));
3976 #line 1924 "parse.y"
3981 #line 1925 "parse.y"
3986 #line 1928 "parse.y"
3988 if(strcmp((yyvsp[0].id),"type")==0) {
3989 Node *node = node_new (CHECK_NODE,
3990 "chtype", TYPE_CHECK,
3992 checks = g_list_append(checks,node);
3993 } else if(strcmp((yyvsp[0].id),"null")==0) {
3994 Node *node = node_new (CHECK_NODE,
3995 "chtype", NULL_CHECK,
3997 checks = g_list_append(checks,node);
3999 yyerror(_("parse error"));
4002 g_free((yyvsp[0].id));
4007 #line 1945 "parse.y"
4009 Node *node = node_new (CHECK_NODE,
4011 "number:steal", (yyvsp[0].id),
4013 checks = g_list_append(checks,node);
4018 #line 1952 "parse.y"
4020 Node *node = node_new (CHECK_NODE,
4022 "number:steal", (yyvsp[0].id),
4024 checks = g_list_append(checks,node);
4029 #line 1959 "parse.y"
4031 Node *node = node_new (CHECK_NODE,
4033 "number:steal", (yyvsp[0].id),
4035 checks = g_list_append(checks,node);
4040 #line 1966 "parse.y"
4042 Node *node = node_new (CHECK_NODE,
4044 "number:steal", (yyvsp[0].id),
4046 checks = g_list_append(checks,node);
4051 #line 1973 "parse.y"
4053 Node *node = node_new (CHECK_NODE,
4055 "number:steal", (yyvsp[0].id),
4057 checks = g_list_append(checks,node);
4062 #line 1980 "parse.y"
4064 Node *node = node_new (CHECK_NODE,
4066 "number:steal", (yyvsp[0].id),
4068 checks = g_list_append(checks,node);
4073 #line 1989 "parse.y"
4075 Node *node = node_new (ENUMDEF_NODE,
4076 "etype:steal", (yyvsp[-1].id),
4077 "prefix:steal", (yyvsp[-5].id),
4078 "values:steal", enum_vals,
4081 nodes = g_list_append (nodes, node);
4086 #line 1998 "parse.y"
4088 Node *node = node_new (ENUMDEF_NODE,
4089 "etype:steal", (yyvsp[-1].id),
4090 "prefix:steal", (yyvsp[-6].id),
4091 "values:steal", enum_vals,
4094 nodes = g_list_append (nodes, node);
4099 #line 2009 "parse.y"
4104 #line 2010 "parse.y"
4109 #line 2013 "parse.y"
4112 char *num = (yyvsp[0].id);
4114 /* A float value, that's a bad enum */
4115 if (num[0] >= '0' &&
4117 strchr (num, '.') != NULL) {
4118 g_free ((yyvsp[-2].id));
4120 yyerror(_("parse error (enumerator value not integer constant)"));
4124 node = node_new (ENUMVALUE_NODE,
4125 "name:steal", (yyvsp[-2].id),
4128 enum_vals = g_list_append (enum_vals, node);
4133 #line 2033 "parse.y"
4137 node = node_new (ENUMVALUE_NODE,
4138 "name:steal", (yyvsp[0].id),
4140 enum_vals = g_list_append (enum_vals, node);
4145 #line 2043 "parse.y"
4147 Node *node = node_new (FLAGS_NODE,
4148 "ftype:steal", (yyvsp[-1].id),
4149 "prefix:steal", (yyvsp[-5].id),
4150 "values:steal", flag_vals,
4153 nodes = g_list_append (nodes, node);
4158 #line 2052 "parse.y"
4160 Node *node = node_new (FLAGS_NODE,
4161 "ftype:steal", (yyvsp[-1].id),
4162 "prefix:steal", (yyvsp[-6].id),
4163 "values:steal", flag_vals,
4166 nodes = g_list_append (nodes, node);
4171 #line 2063 "parse.y"
4173 flag_vals = g_list_append (flag_vals, (yyvsp[0].id));
4178 #line 2066 "parse.y"
4180 flag_vals = g_list_append (flag_vals, (yyvsp[0].id));
4185 #line 2071 "parse.y"
4187 Node *node = node_new (ERROR_NODE,
4188 "etype:steal", (yyvsp[-1].id),
4189 "prefix:steal", (yyvsp[-5].id),
4190 "values:steal", error_vals,
4193 nodes = g_list_append (nodes, node);
4198 #line 2080 "parse.y"
4200 Node *node = node_new (ERROR_NODE,
4201 "etype:steal", (yyvsp[-1].id),
4202 "prefix:steal", (yyvsp[-6].id),
4203 "values:steal", error_vals,
4206 nodes = g_list_append (nodes, node);
4211 #line 2091 "parse.y"
4213 error_vals = g_list_append (error_vals, (yyvsp[0].id));
4218 #line 2094 "parse.y"
4220 error_vals = g_list_append (error_vals, (yyvsp[0].id));
4225 #line 2100 "parse.y"
4226 { (yyval.id) = (yyvsp[0].id); }
4230 #line 2101 "parse.y"
4232 (yyval.id) = g_strconcat("-",(yyvsp[0].id),NULL);
4233 g_free((yyvsp[0].id));
4238 #line 2105 "parse.y"
4239 { (yyval.id) = (yyvsp[0].id); }
4243 #line 2106 "parse.y"
4244 { (yyval.id) = (yyvsp[0].id); }
4250 /* Line 1037 of yacc.c. */
4251 #line 4252 "y.tab.c"
4257 YY_STACK_PRINT (yyss, yyssp);
4262 /* Now `shift' the result of the reduction. Determine what state
4263 that goes to, based on the state we popped back to and the rule
4264 number reduced by. */
4268 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4269 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4270 yystate = yytable[yystate];
4272 yystate = yydefgoto[yyn - YYNTOKENS];
4277 /*------------------------------------.
4278 | yyerrlab -- here on detecting error |
4279 `------------------------------------*/
4281 /* If not already recovering from an error, report this error. */
4286 yyn = yypact[yystate];
4288 if (YYPACT_NINF < yyn && yyn < YYLAST)
4290 YYSIZE_T yysize = 0;
4291 int yytype = YYTRANSLATE (yychar);
4292 const char* yyprefix;
4296 /* Start YYX at -YYN if negative to avoid negative indexes in
4298 int yyxbegin = yyn < 0 ? -yyn : 0;
4300 /* Stay within bounds of both yycheck and yytname. */
4301 int yychecklim = YYLAST - yyn;
4302 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4305 yyprefix = ", expecting ";
4306 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4307 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
4309 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
4317 yysize += (sizeof ("syntax error, unexpected ")
4318 + yystrlen (yytname[yytype]));
4319 yymsg = (char *) YYSTACK_ALLOC (yysize);
4322 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
4323 yyp = yystpcpy (yyp, yytname[yytype]);
4327 yyprefix = ", expecting ";
4328 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4329 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
4331 yyp = yystpcpy (yyp, yyprefix);
4332 yyp = yystpcpy (yyp, yytname[yyx]);
4337 YYSTACK_FREE (yymsg);
4340 yyerror ("syntax error; also virtual memory exhausted");
4343 #endif /* YYERROR_VERBOSE */
4344 yyerror ("syntax error");
4349 if (yyerrstatus == 3)
4351 /* If just tried and failed to reuse look-ahead token after an
4352 error, discard it. */
4354 if (yychar <= YYEOF)
4356 /* If at end of input, pop the error token,
4357 then the rest of the stack, then return failure. */
4358 if (yychar == YYEOF)
4365 yydestruct ("Error: popping",
4366 yystos[*yyssp], yyvsp);
4371 yydestruct ("Error: discarding", yytoken, &yylval);
4376 /* Else will try to reuse look-ahead token after shifting the error
4381 /*---------------------------------------------------.
4382 | yyerrorlab -- error raised explicitly by YYERROR. |
4383 `---------------------------------------------------*/
4387 /* Pacify GCC when the user code never invokes YYERROR and the label
4388 yyerrorlab therefore never appears in user code. */
4399 /*-------------------------------------------------------------.
4400 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4401 `-------------------------------------------------------------*/
4403 yyerrstatus = 3; /* Each real token shifted decrements this. */
4407 yyn = yypact[yystate];
4408 if (yyn != YYPACT_NINF)
4411 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4419 /* Pop the current state because it cannot handle the error token. */
4424 yydestruct ("Error: popping", yystos[yystate], yyvsp);
4427 YY_STACK_PRINT (yyss, yyssp);
4436 /* Shift the error token. */
4437 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4443 /*-------------------------------------.
4444 | yyacceptlab -- YYACCEPT comes here. |
4445 `-------------------------------------*/
4450 /*-----------------------------------.
4451 | yyabortlab -- YYABORT comes here. |
4452 `-----------------------------------*/
4454 yydestruct ("Error: discarding lookahead",
4461 /*----------------------------------------------.
4462 | yyoverflowlab -- parser overflow comes here. |
4463 `----------------------------------------------*/
4465 yyerror ("parser stack overflow");
4473 YYSTACK_FREE (yyss);
4479 #line 2109 "parse.y"