src/parse.c

   1 /* A Bison parser, made by GNU Bison 2.7.  */
   2
   3 /* Bison implementation for Yacc-like parsers in C
   4
   5       Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* As a special exception, you may create a larger work that contains
  21    part or all of the Bison parser skeleton and distribute that work
  22    under terms of your choice, so long as that work isn't itself a
  23    parser generator using the skeleton or a modified version thereof
  24    as a parser skeleton.  Alternatively, if you modify or redistribute
  25    the parser skeleton itself, you may (at your option) remove this
  26    special exception, which will cause the skeleton and the resulting
  27    Bison output files to be licensed under the GNU General Public
  28    License without this special exception.
  29
  30    This special exception was added by the Free Software Foundation in
  31    version 2.2 of Bison.  */
  32
  33 /* C LALR(1) parser skeleton written by Richard Stallman, by
  34    simplifying the original so-called "semantic" parser.  */
  35
  36 /* All symbols defined below should begin with yy or YY, to avoid
  37    infringing on user name space.  This should be done even for local
  38    variables, as they might otherwise be expanded by user macros.
  39    There are some unavoidable exceptions within include files to
  40    define necessary library symbols; they are noted "INFRINGES ON
  41    USER NAME SPACE" below.  */
  42
  43 /* Identify Bison output.  */
  44 #define YYBISON 1
  45
  46 /* Bison version.  */
  47 #define YYBISON_VERSION "2.7"
  48
  49 /* Skeleton name.  */
  50 #define YYSKELETON_NAME "yacc.c"
  51
  52 /* Pure parsers.  */
  53 #define YYPURE 0
  54
  55 /* Push parsers.  */
  56 #define YYPUSH 0
  57
  58 /* Pull parsers.  */
  59 #define YYPULL 1
  60
  61
  62
  63
  64 /* Copy the first part of user declarations.  */
  65 /* Line 371 of yacc.c  */
  66 #line 23 "parse.y"
  67
  68
  69 #include "config.h"
  70 #include <glib.h>
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74
  75 #include "treefuncs.h"
  76 #include "main.h"
  77 #include "util.h"
  78
  79 /* FIXME: add gettext support */
  80 #define _(x) (x)
  81
  82 GList *nodes = NULL;
  83
  84 static GList *class_nodes = NULL;
  85 Node *class = NULL;
  86 GList *enums = NULL;
  87 static GList *enum_vals = NULL;
  88 static GList *flag_vals = NULL;
  89 static GList *error_vals = NULL;
  90
  91 static gboolean abstract = FALSE;
  92 static char *chunk_size = NULL;
  93 static char *bonobo_object_class = NULL;
  94 static int glade_xml = FALSE;
  95 static GList *interfaces = NULL;
  96 static GList *typestack = NULL;
  97 static GList *funcargs = NULL;
  98 static GList *checks = NULL;
  99 static int has_self = FALSE;
 100 static int vararg = FALSE;
 101 static Method *last_added_method = NULL;
 102
 103 /* destructor and initializer for variables */
 104 static gboolean destructor_unref = FALSE;
 105 static char *destructor = NULL;
 106 static int destructor_line = 0;
 107 static gboolean destructor_simple = TRUE;
 108 static char *initializer = NULL;
 109 static int initializer_line = 0;
 110 static int glade_widget = FALSE;
 111
 112 static char *funcattrs = NULL;
 113 static char *onerror = NULL;
 114 static char *defreturn = NULL;
 115
 116 static GList *gtktypes = NULL;
 117 static char *signal_name=NULL;
 118
 119 static Property *property = NULL;
 120
 121 /* this can be a global as we will only do one function at a time
 122    anyway */
 123 static int the_scope = NO_SCOPE;
 124
 125 void free(void *ptr);
 126 int yylex(void);
 127
 128 extern int ccode_line;
 129 extern int line_no;
 130 extern gboolean for_cpp;
 131
 132 extern char *yytext;
 133
 134 static void
 135 yyerror(char *str)
 136 {
 137         char *out=NULL;
 138         char *p;
 139
 140         if (strcmp (yytext, "\n") == 0 ||
 141             strcmp (yytext, "\r") == 0) {
 142                 out = g_strconcat ("Error: ", str, " before end of line", NULL);
 143         } else if (yytext[0] == '\0') {
 144                 out=g_strconcat("Error: ", str, " at end of input", NULL);
 145         } else {
 146                 char *tmp = g_strdup(yytext);
 147                 while((p=strchr(tmp, '\n')))
 148                         *p='.';
 149
 150                 out=g_strconcat("Error: ", str, " before '", tmp, "'", NULL);
 151                 g_free(tmp);
 152         }
 153
 154         fprintf(stderr, "%s:%d: %s\n", filename, line_no, out);
 155         g_free(out);
 156
 157         exit(1);
 158 }
 159
 160 static Type *
 161 pop_type(void)
 162 {
 163         Type *type = typestack->data;
 164         typestack = g_list_remove(typestack,typestack->data);
 165         return type;
 166 }
 167
 168 static void
 169 push_variable (char *name, int scope, int line_no, char *postfix)
 170 {
 171         Node *var;
 172         Type *type = pop_type ();
 173
 174         type->postfix = postfix;
 175
 176         var = node_new (VARIABLE_NODE,
 177                         "scope", scope,
 178                         "vtype:steal", type,
 179                         "glade_widget", glade_widget,
 180                         "id:steal", name,
 181                         "line_no", line_no,
 182                         "destructor_unref", destructor_unref,
 183                         "destructor:steal", destructor,
 184                         "destructor_line", destructor_line,
 185                         "destructor_simple", destructor_simple,
 186                         "initializer:steal", initializer,
 187                         "initializer_line", initializer_line,
 188                         "initializer_simple", TRUE,
 189                         NULL);
 190         class_nodes = g_list_append(class_nodes, var);
 191         glade_widget = FALSE;
 192 }
 193
 194 static void
 195 push_function (int scope, int method, char *oid, char *id,
 196                GString *cbuf, int line_no, int ccode_line,
 197                gboolean vararg, GList *flags)
 198 {
 199         Node *node;
 200         Type *type;
 201         char *c_cbuf;
 202
 203         g_assert(scope != CLASS_SCOPE);
 204
 205         if(method == INIT_METHOD ||
 206            method == CLASS_INIT_METHOD ||
 207            method == CONSTRUCTOR_METHOD ||
 208            method == DISPOSE_METHOD ||
 209            method == FINALIZE_METHOD) {
 210                 type = (Type *)node_new (TYPE_NODE,
 211                                          "name", "void",
 212                                          NULL);
 213         } else {
 214                 type = pop_type();
 215         }
 216
 217         /* a complicated and ugly test to figure out if we have
 218            the wrong number of types for a signal */
 219         if((method == SIGNAL_FIRST_METHOD ||
 220             method == SIGNAL_LAST_METHOD) &&
 221            g_list_length(gtktypes) != g_list_length(funcargs) &&
 222            !(g_list_length(funcargs) == 1 &&
 223              g_list_length(gtktypes) == 2 &&
 224              strcmp(gtktypes->next->data, "NONE")==0)) {
 225                 error_print(GOB_WARN, line_no,
 226                             _("The number of GTK arguments and "
 227                               "function arguments for a signal "
 228                               "don't seem to match"));
 229         }
 230         if(g_list_length(gtktypes) > 2) {
 231                 GList *li;
 232                 for(li = gtktypes->next; li; li = li->next) {
 233                         if(strcmp(li->data, "NONE")==0) {
 234                                 error_print(GOB_ERROR, line_no,
 235                                             _("NONE can only appear in an "
 236                                               "argument list by itself"));
 237                         }
 238                 }
 239         }
 240         if(cbuf) {
 241                 char *p;
 242                 c_cbuf = p = cbuf->str;
 243                 while(p && *p && (*p==' ' || *p=='\t' || *p=='\n' || *p=='\r'))
 244                         p++;
 245                 if(!p || !*p)
 246                         c_cbuf = NULL;
 247         } else
 248                 c_cbuf = NULL;
 249
 250         if (signal_name == NULL )
 251         {
 252                 GString * buffer=g_string_new("");
 253                 g_string_printf(buffer, "\"%s\"", id);
 254                 signal_name = buffer->str;
 255                 g_string_free(buffer, FALSE);
 256         }
 257         node = node_new (METHOD_NODE,
 258                          "scope", scope,
 259                          "method", method,
 260                          "mtype:steal", type,
 261                          "otype:steal", oid,
 262                          "gtktypes:steal", gtktypes,
 263                          "flags:steal", flags,
 264                          "id:steal", id,
 265                          "signal_name:steal", signal_name,
 266                          "args:steal", funcargs,
 267                          "funcattrs:steal", funcattrs,
 268                          "onerror:steal", onerror,
 269                          "defreturn:steal", defreturn,
 270                          "cbuf:steal", c_cbuf,
 271                          "line_no", line_no,
 272                          "ccode_line", ccode_line,
 273                          "vararg", vararg,
 274                          "unique_id", method_unique_id++,
 275                          NULL);
 276
 277         last_added_method = (Method *)node;
 278
 279         if(cbuf)
 280                 g_string_free(cbuf,
 281                               /*only free segment if we haven't passed it
 282                                 above */
 283                               c_cbuf?FALSE:TRUE);
 284         gtktypes = NULL;
 285         signal_name = NULL;
 286         funcargs = NULL;
 287         funcattrs = NULL;
 288         onerror = NULL;
 289         defreturn = NULL;
 290
 291         class_nodes = g_list_append(class_nodes, node);
 292 }
 293
 294 static void
 295 free_all_global_state(void)
 296 {
 297         g_free(funcattrs);
 298         funcattrs = NULL;
 299         g_free(onerror);
 300         onerror = NULL;
 301         g_free(defreturn);
 302         defreturn = NULL;
 303
 304         g_free(chunk_size);
 305         chunk_size = NULL;
 306
 307         g_list_foreach(gtktypes, (GFunc)g_free, NULL);
 308         g_list_free(gtktypes);
 309         gtktypes = NULL;
 310
 311         node_list_free (funcargs);
 312         funcargs = NULL;
 313 }
 314
 315 static void
 316 push_funcarg(char *name, char *postfix)
 317 {
 318         Node *node;
 319         Type *type = pop_type();
 320
 321         type->postfix = postfix;
 322
 323         node = node_new (FUNCARG_NODE,
 324                          "atype:steal", type,
 325                          "name:steal", name,
 326                          "checks:steal", checks,
 327                          NULL);
 328         checks = NULL;
 329
 330         funcargs = g_list_append(funcargs, node);
 331 }
 332
 333 static void
 334 push_init_arg(char *name, int is_class)
 335 {
 336         Node *node;
 337         Node *type;
 338         char *tn;
 339
 340         if(is_class)
 341                 tn = g_strconcat(((Class *)class)->otype,":Class",NULL);
 342         else
 343                 tn = g_strdup(((Class *)class)->otype);
 344
 345         type = node_new (TYPE_NODE,
 346                          "name:steal", tn,
 347                          "pointer", "*",
 348                          NULL);
 349         node = node_new (FUNCARG_NODE,
 350                          "atype:steal", (Type *)type,
 351                          "name:steal", name,
 352                          NULL);
 353         funcargs = g_list_prepend(funcargs, node);
 354 }
 355
 356 static void
 357 push_self(char *id, gboolean constant)
 358 {
 359         Node *node;
 360         Node *type;
 361         GList *ch = NULL;
 362         type = node_new (TYPE_NODE,
 363                          "name", ((Class *)class)->otype,
 364                          "pointer", constant ? "const *" : "*",
 365                          NULL);
 366         ch = g_list_append (ch, node_new (CHECK_NODE,
 367                                           "chtype", NULL_CHECK,
 368                                           NULL));
 369         ch = g_list_append (ch, node_new (CHECK_NODE,
 370                                           "chtype", TYPE_CHECK,
 371                                           NULL));
 372         node = node_new (FUNCARG_NODE,
 373                          "atype:steal", (Type *)type,
 374                          "name:steal", id,
 375                          "checks:steal", ch,
 376                          NULL);
 377         funcargs = g_list_prepend(funcargs, node);
 378 }
 379
 380 static Variable *
 381 find_var_or_die(const char *id, int line)
 382 {
 383         GList *li;
 384
 385         for(li = class_nodes; li != NULL; li = li->next) {
 386                 Variable *var;
 387                 Node *node = li->data;
 388                 if(node->type != VARIABLE_NODE)
 389                         continue;
 390                 var = li->data;
 391                 if(strcmp(var->id, id)==0)
 392                         return var;
 393         }
 394
 395         error_printf(GOB_ERROR, line, _("Variable %s not defined here"), id);
 396
 397         g_assert_not_reached();
 398         return NULL;
 399 }
 400
 401 static gboolean
 402 set_attr_value(char *type, char *val)
 403 {
 404         if(strcmp(type, "attr")==0) {
 405                 if(!funcattrs) {
 406                         funcattrs = val;
 407                         return TRUE;
 408                 } else
 409                         return FALSE;
 410         } else if(strcmp(type, "onerror")==0) {
 411                 if(!onerror) {
 412                         onerror = val;
 413                         return TRUE;
 414                 } else
 415                         return FALSE;
 416         } else if(strcmp(type, "defreturn")==0) {
 417                 if(!defreturn) {
 418                         defreturn = val;
 419                         return TRUE;
 420                 } else
 421                         return FALSE;
 422         }
 423         return FALSE;
 424 }
 425
 426 static void
 427 export_accessors (const char *var_name,
 428                   gboolean do_get,
 429                   int get_lineno,
 430                   gboolean do_set,
 431                   int set_lineno,
 432                   Type *type,
 433                   const char *gtktype,
 434                   int lineno)
 435 {
 436         Type *the_type;
 437
 438         if (type != NULL)
 439                 the_type = (Type *)node_copy ((Node *)type);
 440         else
 441                 the_type = get_tree_type (gtktype, TRUE);
 442
 443         if (the_type == NULL) {
 444                 error_print (GOB_ERROR, line_no,
 445                              _("Cannot determine type of property or argument"));
 446                 return;
 447         }
 448
 449         if (do_get) {
 450                 char *get_id = g_strdup_printf ("get_%s", var_name);
 451                 GString *get_cbuf = g_string_new (NULL);
 452                 Node *node1 = node_new (TYPE_NODE,
 453                                         "name", the_type->name,
 454                                         "pointer", the_type->pointer,
 455                                         "postfix", the_type->postfix,
 456                                         NULL);
 457                 Node *node3 = node_new (TYPE_NODE,
 458                                         "name", class->class.otype,
 459                                         "pointer", "*",
 460                                         NULL);
 461
 462                 g_string_sprintf (get_cbuf,
 463                                   "\t%s%s val; "
 464                                   "g_object_get (G_OBJECT (self), \"%s\", "
 465                                   "&val, NULL); "
 466                                   "return val;\n",
 467                                   the_type->name,
 468                                   the_type->pointer ? the_type->pointer : "",
 469                                   var_name);
 470
 471                 typestack = g_list_prepend (typestack, node1);
 472                 typestack = g_list_prepend (typestack, node3);
 473
 474                 push_funcarg ("self", FALSE);
 475
 476                 push_function (PUBLIC_SCOPE, REGULAR_METHOD, NULL,
 477                                get_id, get_cbuf, get_lineno,
 478                                lineno, FALSE, NULL);
 479         }
 480
 481         if (do_set) {
 482                 char *set_id = g_strdup_printf ("set_%s", var_name);
 483                 GString *set_cbuf = g_string_new (NULL);
 484                 Node *node1 = node_new (TYPE_NODE,
 485                                         "name", the_type->name,
 486                                         "pointer", the_type->pointer,
 487                                         "postfix", the_type->postfix,
 488                                         NULL);
 489                 Node *node2 = node_new (TYPE_NODE,
 490                                         "name", "void",
 491                                         NULL);
 492                 Node *node3 = node_new (TYPE_NODE,
 493                                         "name", class->class.otype,
 494                                         "pointer", "*",
 495                                         NULL);
 496
 497                 g_string_sprintf (set_cbuf,
 498                                   "\tg_object_set (G_OBJECT (self), "
 499                                   "\"%s\", val, NULL);\n",
 500                                   var_name);
 501
 502                 typestack = g_list_prepend (typestack, node2);
 503                 typestack = g_list_prepend (typestack, node1);
 504                 typestack = g_list_prepend (typestack, node3);
 505
 506                 push_funcarg ("self", FALSE);
 507                 push_funcarg ("val", FALSE);
 508
 509                 typestack = g_list_prepend (typestack, node2);
 510                 push_function (PUBLIC_SCOPE, REGULAR_METHOD, NULL,
 511                                set_id, set_cbuf, set_lineno,
 512                                lineno, FALSE, NULL);
 513         }
 514
 515         node_free ((Node *)the_type);
 516 }
 517
 518 static char *
 519 get_prop_enum_flag_cast (Property *prop)
 520 {
 521         char *tmp, *ret;
 522         if (prop->extra_gtktype == NULL ||
 523         /* HACK!  just in case someone made this
 524          * work with 2.0.0 by using the TYPE
 525          * macro directly */
 526             ((strstr (prop->extra_gtktype, "_TYPE_") != NULL ||
 527               strstr (prop->extra_gtktype, "TYPE_") == prop->extra_gtktype) &&
 528              strchr (prop->extra_gtktype, ':') == NULL)) {
 529                 if (prop->ptype != NULL)
 530                         return get_type (prop->ptype, TRUE);
 531                 else
 532                         return g_strdup ("");
 533         }
 534         tmp = remove_sep (prop->extra_gtktype);
 535         ret = g_strdup_printf ("(%s) ", tmp);
 536         g_free (tmp);
 537         return ret;
 538 }
 539
 540 static void
 541 add_construct_glade (char * file, char * root, char * domain)
 542 {
 543         Node *var;
 544         Type * type;
 545
 546         type = (Type *)node_new (TYPE_NODE,
 547                                  "name", "GladeXML",
 548                                  "pointer", "*",
 549                                  NULL);
 550         initializer = g_strdup_printf("\t{\n"
 551                                       "\tGtkWidget * root;\n"
 552                                       "\t%%1$s->_priv->_glade_xml = glade_xml_new(%s, %s, %s);\n"
 553                                       "\troot = glade_xml_get_widget(%%1$s->_priv->_glade_xml, %s);\n"
 554                                       "\tgtk_widget_show(root);\n"
 555                                       "\tgtk_container_add(GTK_CONTAINER(%%1$s), root);\n"
 556                                       "\tglade_xml_signal_autoconnect_full(%%1$s->_priv->_glade_xml, (GladeXMLConnectFunc)___glade_xml_connect_foreach, (gpointer)%%1$s);\n"
 557                                       "}\n", file, root, domain ? domain : "NULL", root);
 558
 559         var = node_new (VARIABLE_NODE,
 560                         "scope", PRIVATE_SCOPE,
 561                         "vtype:steal", type,
 562                         "glade_widget", FALSE,
 563                         "id:steal", "_glade_xml",
 564                         "destructor_unref", FALSE,
 565                         "destructor", "g_object_unref",
 566                         "destructor_simple", TRUE,
 567                         "initializer", initializer,
 568                         "initializer_simple", FALSE,
 569                         NULL);
 570         class_nodes = g_list_prepend(class_nodes, var);
 571 }
 572
 573 static void
 574 property_link_and_export (Node *node)
 575 {
 576         Property *prop = (Property *)node;
 577
 578         if (prop->link) {
 579                 const char *root;
 580                 char *get = NULL, *set = NULL;
 581                 Variable *var;
 582
 583                 if (prop->set != NULL ||
 584                     prop->get != NULL) {
 585                         error_print (GOB_ERROR, prop->line_no,
 586                                      _("Property linking requested, but "
 587                                        "getters and setters exist"));
 588                 }
 589
 590                 var = find_var_or_die (prop->name, prop->line_no);
 591                 if(var->scope == PRIVATE_SCOPE) {
 592                         root = "self->_priv";
 593                 } else if (var->scope == CLASS_SCOPE) {
 594                         root = "SELF_GET_CLASS(self)";
 595                         if (no_self_alias)
 596                                 error_print (GOB_ERROR, prop->line_no,
 597                                              _("Self aliases needed when autolinking to a classwide member"));
 598                 } else {
 599                         root = "self";
 600                 }
 601
 602                 if (strcmp (prop->gtktype, "STRING") == 0) {
 603                         set = g_strdup_printf("{ char *old = %s->%s; "
 604                                               "%s->%s = g_value_dup_string (VAL); g_free (old); }",
 605                                               root, prop->name,
 606                                               root, prop->name);
 607                         get = g_strdup_printf("g_value_set_string (VAL, %s->%s);",
 608                                               root, prop->name);
 609                 } else if (strcmp (prop->gtktype, "OBJECT") == 0) {
 610                         char *cast;
 611                         if (prop->extra_gtktype != NULL) {
 612                                 cast = remove_sep (prop->extra_gtktype);
 613                         } else {
 614                                 cast = g_strdup ("void");
 615                         }
 616                         set = g_strdup_printf("{ GObject *___old = (GObject *)%s->%s; "
 617                                               "%s->%s = (%s *)g_value_dup_object (VAL); "
 618                                               "if (___old != NULL) { "
 619                                                 "g_object_unref (G_OBJECT (___old)); "
 620                                               "} "
 621                                               "}",
 622                                               root, prop->name,
 623                                               root, prop->name,
 624                                               cast);
 625                         get = g_strdup_printf ("g_value_set_object (VAL, "
 626                                                "(gpointer)%s->%s);",
 627                                                root, prop->name);
 628                         g_free (cast);
 629                 } else if (strcmp (prop->gtktype, "BOXED") == 0) {
 630                         char *type = make_me_type (prop->extra_gtktype,
 631                                                    "G_TYPE_BOXED");
 632                         if (prop->extra_gtktype == NULL) {
 633                                 error_print (GOB_ERROR, prop->line_no,
 634                                              _("Property linking requested for BOXED, but "
 635                                                "boxed_type not set"));
 636                         }
 637                         set = g_strdup_printf("{ gpointer ___old = (gpointer)%s->%s; "
 638                                               "gpointer ___new = (gpointer)g_value_get_boxed (VAL); "
 639                                               "if (___new != ___old) { "
 640                                                 "if (___old != NULL) g_boxed_free (%s, ___old); "
 641                                                 "if (___new != NULL) %s->%s = g_boxed_copy (%s, ___new); "
 642                                                 "else %s->%s = NULL;"
 643                                               "} "
 644                                               "}",
 645                                               root, prop->name,
 646                                               type,
 647                                               root, prop->name,
 648                                               type,
 649                                               root, prop->name);
 650                         get = g_strdup_printf("g_value_set_boxed (VAL, %s->%s);",
 651                                               root, prop->name);
 652                         g_free (type);
 653                 } else {
 654                         char *set_func;
 655                         char *get_func;
 656                         const char *getcast = "";
 657                         const char *setcast = "";
 658                         char *to_free = NULL;
 659                         set_func = g_strdup_printf ("g_value_set_%s", prop->gtktype);
 660                         g_strdown (set_func);
 661                         get_func = g_strdup_printf ("g_value_get_%s", prop->gtktype);
 662                         g_strdown (get_func);
 663
 664                         if (for_cpp) {
 665                                 if (strcmp (prop->gtktype, "FLAGS") == 0) {
 666                                         setcast = "(guint) ";
 667                                         getcast = to_free =
 668                                                 get_prop_enum_flag_cast (prop);
 669                                 } else if (strcmp (prop->gtktype, "ENUM") == 0) {
 670                                         setcast = "(gint) ";
 671                                         getcast = to_free =
 672                                                 get_prop_enum_flag_cast (prop);
 673                                }  else if (strcmp (prop->gtktype, "POINTER") == 0) {
 674                                        setcast = "(gpointer) ";
 675                                        getcast = g_strdup_printf ("(%s%s) ",
 676                                                                   prop->ptype->name,
 677                                                                   prop->ptype->pointer ? prop->ptype->pointer : "");
 678                                 }
 679                         }
 680
 681                         set = g_strdup_printf("%s->%s = %s%s (VAL);",
 682                                               root, prop->name,
 683                                               getcast,
 684                                               get_func);
 685                         get = g_strdup_printf("%s (VAL, %s%s->%s);",
 686                                               set_func,
 687                                               setcast,
 688                                               root, prop->name);
 689
 690                         g_free (get_func);
 691                         g_free (set_func);
 692                         g_free (to_free);
 693                 }
 694
 695                 node_set (node,
 696                           "get:steal", get,
 697                           "get_line", prop->line_no,
 698                           "set:steal", set,
 699                           "set_line", prop->line_no,
 700                           NULL);
 701         }
 702
 703         if (prop->export) {
 704                 export_accessors (prop->name,
 705                                   prop->get != NULL, prop->get_line,
 706                                   prop->set != NULL,  prop->set_line,
 707                                   prop->ptype,
 708                                   prop->gtktype,
 709                                   prop->line_no);
 710         }
 711 }
 712
 713
 714 static char *
 715 debool (char *s)
 716 {
 717         if (strcmp (s, "BOOL") == 0) {
 718                 error_print (GOB_WARN, line_no,
 719                             _("BOOL type is deprecated, please use BOOLEAN"));
 720                 g_free (s);
 721                 return g_strdup ("BOOLEAN");
 722         } else {
 723                 return s;
 724         }
 725 }
 726
 727 static void
 728 ensure_property (void)
 729 {
 730         if (property == NULL)
 731                 property = (Property *)node_new (PROPERTY_NODE, NULL);
 732 }
 733
 734
 735 /* Line 371 of yacc.c  */
 736 #line 737 "parse.c"
 737
 738 # ifndef YY_NULL
 739 #  if defined __cplusplus && 201103L <= __cplusplus
 740 #   define YY_NULL nullptr
 741 #  else
 742 #   define YY_NULL 0
 743 #  endif
 744 # endif
 745
 746 /* Enabling verbose error messages.  */
 747 #ifdef YYERROR_VERBOSE
 748 # undef YYERROR_VERBOSE
 749 # define YYERROR_VERBOSE 1
 750 #else
 751 # define YYERROR_VERBOSE 0
 752 #endif
 753
 754 /* In a future release of Bison, this section will be replaced
 755    by #include "y.tab.h".  */
 756 #ifndef YY_YY_PARSE_H_INCLUDED
 757 # define YY_YY_PARSE_H_INCLUDED
 758 /* Enabling traces.  */
 759 #ifndef YYDEBUG
 760 # define YYDEBUG 1
 761 #endif
 762 #if YYDEBUG
 763 extern int yydebug;
 764 #endif
 765
 766 /* Tokens.  */
 767 #ifndef YYTOKENTYPE
 768 # define YYTOKENTYPE
 769    /* Put the tokens into the symbol table, so that GDB and other debuggers
 770       know about them.  */
 771    enum yytokentype {
 772      CLASS = 258,
 773      FROM = 259,
 774      CONST = 260,
 775      VOID = 261,
 776      STRUCT = 262,
 777      UNION = 263,
 778      ENUM = 264,
 779      THREEDOTS = 265,
 780      SIGNED = 266,
 781      UNSIGNED = 267,
 782      LONG = 268,
 783      SHORT = 269,
 784      INT = 270,
 785      FLOAT = 271,
 786      DOUBLE = 272,
 787      CHAR = 273,
 788      TOKEN = 274,
 789      NUMBER = 275,
 790      TYPETOKEN = 276,
 791      ARRAY_DIM = 277,
 792      SINGLE_CHAR = 278,
 793      CCODE = 279,
 794      CTCODE = 280,
 795      ADCODE = 281,
 796      HTCODE = 282,
 797      PHCODE = 283,
 798      HCODE = 284,
 799      ACODE = 285,
 800      ATCODE = 286,
 801      STRING = 287,
 802      PUBLIC = 288,
 803      PRIVATE = 289,
 804      PROTECTED = 290,
 805      CLASSWIDE = 291,
 806      PROPERTY = 292,
 807      ARGUMENT = 293,
 808      VIRTUAL = 294,
 809      SIGNAL = 295,
 810      OVERRIDE = 296,
 811      NAME = 297,
 812      NICK = 298,
 813      BLURB = 299,
 814      MAXIMUM = 300,
 815      MINIMUM = 301,
 816      DEFAULT_VALUE = 302,
 817      ERROR = 303,
 818      FLAGS = 304,
 819      TYPE = 305,
 820      FLAGS_TYPE = 306,
 821      ENUM_TYPE = 307,
 822      PARAM_TYPE = 308,
 823      BOXED_TYPE = 309,
 824      OBJECT_TYPE = 310
 825    };
 826 #endif
 827 /* Tokens.  */
 828 #define CLASS 258
 829 #define FROM 259
 830 #define CONST 260
 831 #define VOID 261
 832 #define STRUCT 262
 833 #define UNION 263
 834 #define ENUM 264
 835 #define THREEDOTS 265
 836 #define SIGNED 266
 837 #define UNSIGNED 267
 838 #define LONG 268
 839 #define SHORT 269
 840 #define INT 270
 841 #define FLOAT 271
 842 #define DOUBLE 272
 843 #define CHAR 273
 844 #define TOKEN 274
 845 #define NUMBER 275
 846 #define TYPETOKEN 276
 847 #define ARRAY_DIM 277
 848 #define SINGLE_CHAR 278
 849 #define CCODE 279
 850 #define CTCODE 280
 851 #define ADCODE 281
 852 #define HTCODE 282
 853 #define PHCODE 283
 854 #define HCODE 284
 855 #define ACODE 285
 856 #define ATCODE 286
 857 #define STRING 287
 858 #define PUBLIC 288
 859 #define PRIVATE 289
 860 #define PROTECTED 290
 861 #define CLASSWIDE 291
 862 #define PROPERTY 292
 863 #define ARGUMENT 293
 864 #define VIRTUAL 294
 865 #define SIGNAL 295
 866 #define OVERRIDE 296
 867 #define NAME 297
 868 #define NICK 298
 869 #define BLURB 299
 870 #define MAXIMUM 300
 871 #define MINIMUM 301
 872 #define DEFAULT_VALUE 302
 873 #define ERROR 303
 874 #define FLAGS 304
 875 #define TYPE 305
 876 #define FLAGS_TYPE 306
 877 #define ENUM_TYPE 307
 878 #define PARAM_TYPE 308
 879 #define BOXED_TYPE 309
 880 #define OBJECT_TYPE 310
 881
 882
 883
 884 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 885 typedef union YYSTYPE
 886 {
 887 /* Line 387 of yacc.c  */
 888 #line 692 "parse.y"
 889
 890         char *id;
 891         GString *cbuf;
 892         GList *list;
 893         int line;
 894         int sigtype;
 895
 896
 897 /* Line 387 of yacc.c  */
 898 #line 899 "parse.c"
 899 } YYSTYPE;
 900 # define YYSTYPE_IS_TRIVIAL 1
 901 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 902 # define YYSTYPE_IS_DECLARED 1
 903 #endif
 904
 905 extern YYSTYPE yylval;
 906
 907 #ifdef YYPARSE_PARAM
 908 #if defined __STDC__ || defined __cplusplus
 909 int yyparse (void *YYPARSE_PARAM);
 910 #else
 911 int yyparse ();
 912 #endif
 913 #else /* ! YYPARSE_PARAM */
 914 #if defined __STDC__ || defined __cplusplus
 915 int yyparse (void);
 916 #else
 917 int yyparse ();
 918 #endif
 919 #endif /* ! YYPARSE_PARAM */
 920
 921 #endif /* !YY_YY_PARSE_H_INCLUDED  */
 922
 923 /* Copy the second part of user declarations.  */
 924
 925 /* Line 390 of yacc.c  */
 926 #line 927 "parse.c"
 927
 928 #ifdef short
 929 # undef short
 930 #endif
 931
 932 #ifdef YYTYPE_UINT8
 933 typedef YYTYPE_UINT8 yytype_uint8;
 934 #else
 935 typedef unsigned char yytype_uint8;
 936 #endif
 937
 938 #ifdef YYTYPE_INT8
 939 typedef YYTYPE_INT8 yytype_int8;
 940 #elif (defined __STDC__ || defined __C99__FUNC__ \
 941      || defined __cplusplus || defined _MSC_VER)
 942 typedef signed char yytype_int8;
 943 #else
 944 typedef short int yytype_int8;
 945 #endif
 946
 947 #ifdef YYTYPE_UINT16
 948 typedef YYTYPE_UINT16 yytype_uint16;
 949 #else
 950 typedef unsigned short int yytype_uint16;
 951 #endif
 952
 953 #ifdef YYTYPE_INT16
 954 typedef YYTYPE_INT16 yytype_int16;
 955 #else
 956 typedef short int yytype_int16;
 957 #endif
 958
 959 #ifndef YYSIZE_T
 960 # ifdef __SIZE_TYPE__
 961 #  define YYSIZE_T __SIZE_TYPE__
 962 # elif defined size_t
 963 #  define YYSIZE_T size_t
 964 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 965      || defined __cplusplus || defined _MSC_VER)
 966 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 967 #  define YYSIZE_T size_t
 968 # else
 969 #  define YYSIZE_T unsigned int
 970 # endif
 971 #endif
 972
 973 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 974
 975 #ifndef YY_
 976 # if defined YYENABLE_NLS && YYENABLE_NLS
 977 #  if ENABLE_NLS
 978 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 979 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
 980 #  endif
 981 # endif
 982 # ifndef YY_
 983 #  define YY_(Msgid) Msgid
 984 # endif
 985 #endif
 986
 987 /* Suppress unused-variable warnings by "using" E.  */
 988 #if ! defined lint || defined __GNUC__
 989 # define YYUSE(E) ((void) (E))
 990 #else
 991 # define YYUSE(E) /* empty */
 992 #endif
 993
 994 /* Identity function, used to suppress warnings about constant conditions.  */
 995 #ifndef lint
 996 # define YYID(N) (N)
 997 #else
 998 #if (defined __STDC__ || defined __C99__FUNC__ \
 999      || defined __cplusplus || defined _MSC_VER)
1000 static int
1001 YYID (int yyi)
1002 #else
1003 static int
1004 YYID (yyi)
1005     int yyi;
1006 #endif
1007 {
1008   return yyi;
1009 }
1010 #endif
1011
1012 #if ! defined yyoverflow || YYERROR_VERBOSE
1013
1014 /* The parser invokes alloca or malloc; define the necessary symbols.  */
1015
1016 # ifdef YYSTACK_USE_ALLOCA
1017 #  if YYSTACK_USE_ALLOCA
1018 #   ifdef __GNUC__
1019 #    define YYSTACK_ALLOC __builtin_alloca
1020 #   elif defined __BUILTIN_VA_ARG_INCR
1021 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1022 #   elif defined _AIX
1023 #    define YYSTACK_ALLOC __alloca
1024 #   elif defined _MSC_VER
1025 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1026 #    define alloca _alloca
1027 #   else
1028 #    define YYSTACK_ALLOC alloca
1029 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1030      || defined __cplusplus || defined _MSC_VER)
1031 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1032       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
1033 #     ifndef EXIT_SUCCESS
1034 #      define EXIT_SUCCESS 0
1035 #     endif
1036 #    endif
1037 #   endif
1038 #  endif
1039 # endif
1040
1041 # ifdef YYSTACK_ALLOC
1042    /* Pacify GCC's `empty if-body' warning.  */
1043 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1044 #  ifndef YYSTACK_ALLOC_MAXIMUM
1045     /* The OS might guarantee only one guard page at the bottom of the stack,
1046        and a page size can be as small as 4096 bytes.  So we cannot safely
1047        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
1048        to allow for a few compiler-allocated temporary stack slots.  */
1049 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1050 #  endif
1051 # else
1052 #  define YYSTACK_ALLOC YYMALLOC
1053 #  define YYSTACK_FREE YYFREE
1054 #  ifndef YYSTACK_ALLOC_MAXIMUM
1055 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1056 #  endif
1057 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
1058        && ! ((defined YYMALLOC || defined malloc) \
1059              && (defined YYFREE || defined free)))
1060 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1061 #   ifndef EXIT_SUCCESS
1062 #    define EXIT_SUCCESS 0
1063 #   endif
1064 #  endif
1065 #  ifndef YYMALLOC
1066 #   define YYMALLOC malloc
1067 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1068      || defined __cplusplus || defined _MSC_VER)
1069 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1070 #   endif
1071 #  endif
1072 #  ifndef YYFREE
1073 #   define YYFREE free
1074 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1075      || defined __cplusplus || defined _MSC_VER)
1076 void free (void *); /* INFRINGES ON USER NAME SPACE */
1077 #   endif
1078 #  endif
1079 # endif
1080 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1081
1082
1083 #if (! defined yyoverflow \
1084      && (! defined __cplusplus \
1085          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1086
1087 /* A type that is properly aligned for any stack member.  */
1088 union yyalloc
1089 {
1090   yytype_int16 yyss_alloc;
1091   YYSTYPE yyvs_alloc;
1092 };
1093
1094 /* The size of the maximum gap between one aligned stack and the next.  */
1095 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1096
1097 /* The size of an array large to enough to hold all stacks, each with
1098    N elements.  */
1099 # define YYSTACK_BYTES(N) \
1100      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1101       + YYSTACK_GAP_MAXIMUM)
1102
1103 # define YYCOPY_NEEDED 1
1104
1105 /* Relocate STACK from its old location to the new one.  The
1106    local variables YYSIZE and YYSTACKSIZE give the old and new number of
1107    elements in the stack, and YYPTR gives the new location of the
1108    stack.  Advance YYPTR to a properly aligned location for the next
1109    stack.  */
1110 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
1111     do                                                                  \
1112       {                                                                 \
1113         YYSIZE_T yynewbytes;                                            \
1114         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
1115         Stack = &yyptr->Stack_alloc;                                    \
1116         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1117         yyptr += yynewbytes / sizeof (*yyptr);                          \
1118       }                                                                 \
1119     while (YYID (0))
1120
1121 #endif
1122
1123 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1124 /* Copy COUNT objects from SRC to DST.  The source and destination do
1125    not overlap.  */
1126 # ifndef YYCOPY
1127 #  if defined __GNUC__ && 1 < __GNUC__
1128 #   define YYCOPY(Dst, Src, Count) \
1129       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
1130 #  else
1131 #   define YYCOPY(Dst, Src, Count)              \
1132       do                                        \
1133         {                                       \
1134           YYSIZE_T yyi;                         \
1135           for (yyi = 0; yyi < (Count); yyi++)   \
1136             (Dst)[yyi] = (Src)[yyi];            \
1137         }                                       \
1138       while (YYID (0))
1139 #  endif
1140 # endif
1141 #endif /* !YYCOPY_NEEDED */
1142
1143 /* YYFINAL -- State number of the termination state.  */
1144 #define YYFINAL  25
1145 /* YYLAST -- Last index in YYTABLE.  */
1146 #define YYLAST   612
1147
1148 /* YYNTOKENS -- Number of terminals.  */
1149 #define YYNTOKENS  69
1150 /* YYNNTS -- Number of nonterminals.  */
1151 #define YYNNTS  53
1152 /* YYNRULES -- Number of rules.  */
1153 #define YYNRULES  200
1154 /* YYNRULES -- Number of states.  */
1155 #define YYNSTATES  425
1156
1157 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1158 #define YYUNDEFTOK  2
1159 #define YYMAXUTOK   310
1160
1161 #define YYTRANSLATE(YYX)                                                \
1162   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1163
1164 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1165 static const yytype_uint8 yytranslate[] =
1166 {
1167        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1168        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1169        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1170        2,     2,     2,    67,     2,     2,     2,     2,     2,     2,
1171       58,    59,    64,     2,    62,    68,     2,     2,     2,     2,
1172        2,     2,     2,     2,     2,     2,     2,     2,     2,    60,
1173       66,    61,    65,     2,     2,     2,     2,     2,     2,     2,
1174        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1175        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1176        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1177        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1178        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1179        2,     2,     2,    56,    63,    57,     2,     2,     2,     2,
1180        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1181        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1182        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1183        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1184        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1185        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1186        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1187        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1188        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1189        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1190        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1191        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1192        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1193        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1194       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1195       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1196       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1197       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1198       55
1199 };
1200
1201 #if YYDEBUG
1202 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1203    YYRHS.  */
1204 static const yytype_uint16 yyprhs[] =
1205 {
1206        0,     0,     3,     7,    10,    13,    15,    17,    19,    21,
1207       23,    25,    27,    29,    31,    34,    37,    40,    43,    45,
1208       47,    49,    51,    56,    60,    66,    67,    72,    78,    84,
1209       90,    97,   105,   112,   120,   123,   125,   127,   130,   134,
1210      136,   138,   140,   142,   144,   146,   148,   150,   153,   157,
1211      160,   164,   167,   170,   172,   174,   176,   177,   183,   190,
1212      203,   213,   220,   224,   225,   237,   246,   252,   256,   257,
1213      261,   263,   265,   270,   272,   274,   278,   282,   286,   290,
1214      294,   298,   302,   306,   310,   314,   318,   322,   326,   330,
1215      334,   338,   342,   346,   348,   354,   356,   360,   361,   365,
1216      367,   370,   372,   374,   376,   379,   382,   385,   389,   393,
1217      396,   399,   402,   404,   407,   409,   412,   414,   416,   418,
1218      420,   422,   424,   426,   428,   430,   432,   434,   436,   438,
1219      441,   444,   448,   451,   453,   457,   461,   464,   466,   471,
1220      477,   481,   483,   486,   488,   499,   511,   521,   531,   540,
1221      552,   561,   567,   570,   575,   582,   583,   585,   588,   590,
1222      592,   595,   598,   602,   607,   612,   614,   618,   620,   624,
1223      626,   629,   633,   640,   648,   651,   653,   655,   658,   661,
1224      665,   669,   673,   677,   685,   694,   698,   700,   704,   706,
1225      714,   723,   727,   729,   737,   746,   750,   752,   754,   757,
1226      759
1227 };
1228
1229 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1230 static const yytype_int8 yyrhs[] =
1231 {
1232       70,     0,    -1,    72,    73,    72,    -1,    73,    72,    -1,
1233       72,    73,    -1,    73,    -1,    24,    -1,    26,    -1,    29,
1234       -1,    27,    -1,    28,    -1,    30,    -1,    31,    -1,    25,
1235       -1,    72,    71,    -1,    72,   114,    -1,    72,   117,    -1,
1236       72,   119,    -1,    71,    -1,   114,    -1,   117,    -1,   119,
1237       -1,    74,    56,    76,    57,    -1,    74,    56,    57,    -1,
1238        3,    21,     4,    21,    75,    -1,    -1,    58,    19,    59,
1239       75,    -1,    58,    19,    19,    59,    75,    -1,    58,    19,
1240       21,    59,    75,    -1,    58,    19,    20,    59,    75,    -1,
1241       58,    19,    32,    32,    59,    75,    -1,    58,    19,    32,
1242       32,    32,    59,    75,    -1,    58,    19,    19,    32,    59,
1243       75,    -1,    58,    19,    19,    32,    32,    59,    75,    -1,
1244       76,    77,    -1,    77,    -1,   105,    -1,    19,   105,    -1,
1245       19,    21,   105,    -1,    82,    -1,    83,    -1,    85,    -1,
1246       60,    -1,    33,    -1,    34,    -1,    35,    -1,    36,    -1,
1247       19,    19,    -1,    19,    56,    24,    -1,    61,   121,    -1,
1248       61,    56,    24,    -1,    79,    80,    -1,    80,    79,    -1,
1249       80,    -1,    79,    -1,    19,    -1,    -1,    78,    94,    19,
1250       81,    60,    -1,    78,    94,    19,    22,    81,    60,    -1,
1251       38,    92,    91,    19,    84,    19,    56,    24,    19,    56,
1252       24,    60,    -1,    38,    92,    91,    19,    84,    19,    56,
1253       24,    60,    -1,    38,    92,    91,    19,    84,    19,    -1,
1254       58,    19,    59,    -1,    -1,    37,    19,    19,    86,    19,
1255       56,    24,    19,    56,    24,    60,    -1,    37,    19,    19,
1256       86,    19,    56,    24,    60,    -1,    37,    19,    19,    86,
1257       60,    -1,    58,    87,    59,    -1,    -1,    87,    62,    90,
1258       -1,    90,    -1,    32,    -1,    19,    58,    32,    59,    -1,
1259      121,    -1,    88,    -1,    42,    61,    88,    -1,    43,    61,
1260       88,    -1,    44,    61,    88,    -1,    45,    61,   121,    -1,
1261       46,    61,   121,    -1,    47,    61,    89,    -1,    49,    61,
1262       93,    -1,    50,    61,    94,    -1,    51,    61,    21,    -1,
1263       51,    61,    19,    -1,    52,    61,    21,    -1,    52,    61,
1264       19,    -1,    53,    61,    21,    -1,    53,    61,    19,    -1,
1265       54,    61,    21,    -1,    54,    61,    19,    -1,    55,    61,
1266       21,    -1,    55,    61,    19,    -1,    19,    -1,    19,    58,
1267       19,    94,    59,    -1,    19,    -1,    58,    93,    59,    -1,
1268       -1,    19,    63,    93,    -1,    19,    -1,    95,    99,    -1,
1269       95,    -1,    96,    -1,    19,    -1,     5,    19,    -1,    19,
1270        5,    -1,    98,    19,    -1,     5,    98,    19,    -1,    98,
1271       19,     5,    -1,    97,    96,    -1,    21,    96,    -1,     5,
1272       96,    -1,    21,    -1,    21,     5,    -1,    97,    -1,    97,
1273        5,    -1,     6,    -1,    18,    -1,    14,    -1,    15,    -1,
1274       13,    -1,    16,    -1,    17,    -1,    11,    -1,    12,    -1,
1275        7,    -1,     8,    -1,     9,    -1,    64,    -1,    64,     5,
1276       -1,    64,    99,    -1,    64,     5,    99,    -1,    19,   102,
1277       -1,   102,    -1,    78,    19,   102,    -1,    19,    78,   102,
1278       -1,    78,   102,    -1,   100,    -1,    19,    58,   103,    59,
1279       -1,    19,    32,    58,   103,    59,    -1,   103,    62,    19,
1280       -1,    19,    -1,    56,    24,    -1,    60,    -1,    40,    92,
1281      101,    94,    19,    58,   108,    59,   106,   104,    -1,    78,
1282       40,    92,   100,    94,    19,    58,   108,    59,   106,   104,
1283       -1,    39,    78,    94,    19,    58,   108,    59,   106,   104,
1284       -1,    78,    39,    94,    19,    58,   108,    59,   106,   104,
1285       -1,    39,    94,    19,    58,   108,    59,   106,   104,    -1,
1286       41,    58,    21,    59,    94,    19,    58,   108,    59,   106,
1287      104,    -1,    78,    94,    19,    58,   108,    59,   106,   104,
1288       -1,    19,    58,    19,    59,   104,    -1,    19,   107,    -1,
1289       19,   107,    19,   107,    -1,    19,   107,    19,   107,    19,
1290      107,    -1,    -1,   121,    -1,    56,    24,    -1,     6,    -1,
1291       19,    -1,    19,     5,    -1,     5,    19,    -1,    19,    62,
1292      109,    -1,    19,     5,    62,   109,    -1,     5,    19,    62,
1293      109,    -1,   109,    -1,   110,    62,    10,    -1,   110,    -1,
1294      110,    62,   111,    -1,   111,    -1,    94,    19,    -1,    94,
1295       19,    22,    -1,    94,    19,    58,    19,   112,    59,    -1,
1296       94,    19,    22,    58,    19,   112,    59,    -1,   112,   113,
1297       -1,   113,    -1,    19,    -1,    65,   121,    -1,    66,   121,
1298       -1,    65,    61,   121,    -1,    66,    61,   121,    -1,    61,
1299       61,   121,    -1,    67,    61,   121,    -1,     9,    19,    56,
1300      115,    57,    21,    60,    -1,     9,    19,    56,   115,    62,
1301       57,    21,    60,    -1,   115,    62,   116,    -1,   116,    -1,
1302       19,    61,   121,    -1,    19,    -1,    49,    19,    56,   118,
1303       57,    21,    60,    -1,    49,    19,    56,   118,    62,    57,
1304       21,    60,    -1,   118,    62,    19,    -1,    19,    -1,    48,
1305       19,    56,   120,    57,    21,    60,    -1,    48,    19,    56,
1306      120,    62,    57,    21,    60,    -1,   120,    62,    19,    -1,
1307       19,    -1,    20,    -1,    68,    20,    -1,    23,    -1,    19,
1308       -1
1309 };
1310
1311 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1312 static const yytype_uint16 yyrline[] =
1313 {
1314        0,   713,   713,   714,   715,   716,   719,   728,   737,   746,
1315      755,   764,   773,   782,   793,   794,   795,   796,   797,   798,
1316      799,   800,   803,   808,   815,   832,   833,   841,   853,   862,
1317      874,   883,   892,   901,   912,   913,   916,   917,   926,   938,
1318      939,   940,   941,   944,   945,   946,   947,   950,   970,   994,
1319      998,  1006,  1007,  1008,  1009,  1010,  1018,  1024,  1027,  1032,
1320     1100,  1154,  1243,  1251,  1256,  1304,  1340,  1356,  1357,  1360,
1321     1361,  1364,  1365,  1377,  1378,  1381,  1387,  1393,  1399,  1405,
1322     1411,  1417,  1423,  1430,  1436,  1442,  1448,  1454,  1460,  1466,
1323     1472,  1478,  1484,  1490,  1515,  1524,  1530,  1531,  1534,  1537,
1324     1543,  1550,  1559,  1562,  1565,  1569,  1573,  1577,  1582,  1590,
1325     1594,  1599,  1603,  1606,  1610,  1613,  1618,  1619,  1620,  1621,
1326     1622,  1623,  1624,  1625,  1626,  1629,  1630,  1631,  1634,  1635,
1327     1636,  1640,  1647,  1659,  1665,  1677,  1689,  1692,  1698,  1701,
1328     1707,  1710,  1715,  1716,  1720,  1743,  1766,  1789,  1812,  1830,
1329     1843,  1853,  1893,  1905,  1925,  1956,  1963,  1964,  1970,  1971,
1330     1982,  1993,  2004,  2014,  2024,  2034,  2037,  2038,  2041,  2042,
1331     2045,  2048,  2051,  2059,  2069,  2070,  2073,  2090,  2097,  2104,
1332     2111,  2118,  2125,  2134,  2143,  2154,  2155,  2158,  2178,  2188,
1333     2197,  2208,  2211,  2216,  2225,  2236,  2239,  2245,  2246,  2250,
1334     2251
1335 };
1336 #endif
1337
1338 #if YYDEBUG || YYERROR_VERBOSE || 0
1339 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1340    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1341 static const char *const yytname[] =
1342 {
1343   "$end", "error", "$undefined", "CLASS", "FROM", "CONST", "VOID",
1344   "STRUCT", "UNION", "ENUM", "THREEDOTS", "SIGNED", "UNSIGNED", "LONG",
1345   "SHORT", "INT", "FLOAT", "DOUBLE", "CHAR", "TOKEN", "NUMBER",
1346   "TYPETOKEN", "ARRAY_DIM", "SINGLE_CHAR", "CCODE", "CTCODE", "ADCODE",
1347   "HTCODE", "PHCODE", "HCODE", "ACODE", "ATCODE", "STRING", "PUBLIC",
1348   "PRIVATE", "PROTECTED", "CLASSWIDE", "PROPERTY", "ARGUMENT", "VIRTUAL",
1349   "SIGNAL", "OVERRIDE", "NAME", "NICK", "BLURB", "MAXIMUM", "MINIMUM",
1350   "DEFAULT_VALUE", "ERROR", "FLAGS", "TYPE", "FLAGS_TYPE", "ENUM_TYPE",
1351   "PARAM_TYPE", "BOXED_TYPE", "OBJECT_TYPE", "'{'", "'}'", "'('", "')'",
1352   "';'", "'='", "','", "'|'", "'*'", "'>'", "'<'", "'!'", "'-'", "$accept",
1353   "prog", "ccode", "ccodes", "class", "classdec", "classflags",
1354   "classcode", "thing", "scope", "destructor", "initializer", "varoptions",
1355   "variable", "argument", "export", "property", "param_spec",
1356   "param_spec_list", "string", "anyval", "param_spec_value", "argtype",
1357   "flags", "flaglist", "type", "specifier_list", "spec_list", "specifier",
1358   "strunionenum", "pointer", "simplesigtype", "fullsigtype", "sigtype",
1359   "tokenlist", "codenocode", "method", "methodmods", "retcode", "funcargs",
1360   "arglist", "arglist1", "arg", "checklist", "check", "enumcode",
1361   "enumvals", "enumval", "flagcode", "flagvals", "errorcode", "errorvals",
1362   "numtok", YY_NULL
1363 };
1364 #endif
1365
1366 # ifdef YYPRINT
1367 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1368    token YYLEX-NUM.  */
1369 static const yytype_uint16 yytoknum[] =
1370 {
1371        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1372      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1373      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1374      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1375      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1376      305,   306,   307,   308,   309,   310,   123,   125,    40,    41,
1377       59,    61,    44,   124,    42,    62,    60,    33,    45
1378 };
1379 # endif
1380
1381 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1382 static const yytype_uint8 yyr1[] =
1383 {
1384        0,    69,    70,    70,    70,    70,    71,    71,    71,    71,
1385       71,    71,    71,    71,    72,    72,    72,    72,    72,    72,
1386       72,    72,    73,    73,    74,    75,    75,    75,    75,    75,
1387       75,    75,    75,    75,    76,    76,    77,    77,    77,    77,
1388       77,    77,    77,    78,    78,    78,    78,    79,    79,    80,
1389       80,    81,    81,    81,    81,    81,    81,    82,    82,    83,
1390       83,    83,    84,    84,    85,    85,    85,    86,    86,    87,
1391       87,    88,    88,    89,    89,    90,    90,    90,    90,    90,
1392       90,    90,    90,    90,    90,    90,    90,    90,    90,    90,
1393       90,    90,    90,    90,    91,    91,    92,    92,    93,    93,
1394       94,    94,    95,    95,    95,    95,    95,    95,    95,    96,
1395       96,    96,    96,    96,    96,    96,    97,    97,    97,    97,
1396       97,    97,    97,    97,    97,    98,    98,    98,    99,    99,
1397       99,    99,   100,   100,   101,   101,   101,   101,   102,   102,
1398      103,   103,   104,   104,   105,   105,   105,   105,   105,   105,
1399      105,   105,   106,   106,   106,   106,   107,   107,   108,   108,
1400      108,   108,   108,   108,   108,   108,   109,   109,   110,   110,
1401      111,   111,   111,   111,   112,   112,   113,   113,   113,   113,
1402      113,   113,   113,   114,   114,   115,   115,   116,   116,   117,
1403      117,   118,   118,   119,   119,   120,   120,   121,   121,   121,
1404      121
1405 };
1406
1407 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1408 static const yytype_uint8 yyr2[] =
1409 {
1410        0,     2,     3,     2,     2,     1,     1,     1,     1,     1,
1411        1,     1,     1,     1,     2,     2,     2,     2,     1,     1,
1412        1,     1,     4,     3,     5,     0,     4,     5,     5,     5,
1413        6,     7,     6,     7,     2,     1,     1,     2,     3,     1,
1414        1,     1,     1,     1,     1,     1,     1,     2,     3,     2,
1415        3,     2,     2,     1,     1,     1,     0,     5,     6,    12,
1416        9,     6,     3,     0,    11,     8,     5,     3,     0,     3,
1417        1,     1,     4,     1,     1,     3,     3,     3,     3,     3,
1418        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
1419        3,     3,     3,     1,     5,     1,     3,     0,     3,     1,
1420        2,     1,     1,     1,     2,     2,     2,     3,     3,     2,
1421        2,     2,     1,     2,     1,     2,     1,     1,     1,     1,
1422        1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
1423        2,     3,     2,     1,     3,     3,     2,     1,     4,     5,
1424        3,     1,     2,     1,    10,    11,     9,     9,     8,    11,
1425        8,     5,     2,     4,     6,     0,     1,     2,     1,     1,
1426        2,     2,     3,     4,     4,     1,     3,     1,     3,     1,
1427        2,     3,     6,     7,     2,     1,     1,     2,     2,     3,
1428        3,     3,     3,     7,     8,     3,     1,     3,     1,     7,
1429        8,     3,     1,     7,     8,     3,     1,     1,     2,     1,
1430        1
1431 };
1432
1433 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1434    Performed when YYTABLE doesn't specify something else to do.  Zero
1435    means the default is an error.  */
1436 static const yytype_uint8 yydefact[] =
1437 {
1438        0,     0,     0,     6,    13,     7,     9,    10,     8,    11,
1439       12,     0,     0,     0,    18,     0,     5,     0,    19,    20,
1440       21,     0,     0,     0,     0,     1,    14,     4,    15,    16,
1441       17,     3,     0,     0,     0,     0,     0,     2,     0,    43,
1442       44,    45,    46,     0,    97,     0,    97,     0,    23,    42,
1443        0,    35,     0,    39,    40,    41,    36,    25,   188,     0,
1444      186,   196,     0,   192,     0,     0,     0,     0,     0,    37,
1445        0,     0,     0,     0,   116,   125,   126,   127,   123,   124,
1446      120,   118,   119,   121,   122,   117,   103,   112,     0,     0,
1447      101,   102,   114,     0,     0,     0,    22,    34,     0,    97,
1448        0,     0,    24,     0,     0,     0,     0,     0,     0,     0,
1449       38,     0,     0,    68,    99,     0,    95,     0,     0,   104,
1450      111,     0,   105,   113,   110,     0,     0,   128,   100,   115,
1451      109,   106,     0,     0,   137,     0,   133,     0,     0,     0,
1452       56,     0,   200,   197,   199,     0,   187,     0,     0,   185,
1453        0,   195,     0,     0,   191,     0,     0,     0,     0,     0,
1454        0,    96,     0,    63,   107,     0,     0,   129,   130,   108,
1455        0,     0,     0,     0,   132,     0,   136,     0,     0,     0,
1456        0,     0,    55,    56,     0,     0,    54,    53,     0,     0,
1457        0,     0,     0,    25,   198,   183,     0,   193,     0,   189,
1458        0,     0,   143,   151,    93,     0,     0,     0,     0,     0,
1459        0,     0,     0,     0,     0,     0,     0,     0,     0,    70,
1460        0,    66,    98,     0,     0,     0,     0,     0,   116,   103,
1461        0,     0,   165,   167,   169,   131,     0,   141,     0,   135,
1462      134,     0,     0,     0,     0,    47,     0,     0,     0,     0,
1463       49,    51,     0,    52,    57,     0,    25,    25,    25,     0,
1464       26,   184,   194,   190,   142,     0,     0,     0,     0,     0,
1465        0,     0,     0,     0,     0,     0,     0,     0,    67,     0,
1466        0,     0,     0,    61,     0,   104,   105,     0,   170,   155,
1467        0,     0,   138,     0,     0,     0,     0,     0,    48,    58,
1468      155,    50,     0,    25,    27,    29,    28,     0,    25,     0,
1469       71,    75,    76,    77,    78,    79,   200,    74,    80,    73,
1470       81,    82,    84,    83,    86,    85,    88,    87,    90,    89,
1471       92,    91,    69,     0,    94,    62,     0,   155,     0,     0,
1472      162,   171,     0,     0,     0,   166,   168,   139,   140,     0,
1473        0,   155,     0,     0,    25,    32,    25,    30,     0,     0,
1474       65,     0,     0,   164,   163,     0,     0,     0,   152,   156,
1475      148,   155,     0,     0,     0,   150,    33,    31,     0,     0,
1476        0,    60,   146,     0,   176,     0,     0,     0,     0,     0,
1477      175,   157,     0,     0,   155,   147,   155,    72,     0,     0,
1478        0,     0,     0,   177,     0,   178,     0,   172,   174,   153,
1479      144,     0,     0,    64,     0,   173,   181,   179,   180,   182,
1480        0,   149,   145,    59,   154
1481 };
1482
1483 /* YYDEFGOTO[NTERM-NUM].  */
1484 static const yytype_int16 yydefgoto[] =
1485 {
1486       -1,    13,    14,    15,    16,    17,   102,    50,    51,    52,
1487      186,   187,   188,    53,    54,   225,    55,   159,   218,   311,
1488      318,   219,   117,    72,   115,   230,    90,    91,    92,    93,
1489      128,   134,   135,   136,   238,   203,    56,   344,   368,   231,
1490      232,   233,   234,   389,   390,    18,    59,    60,    19,    64,
1491       20,    62,   369
1492 };
1493
1494 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1495    STATE-NUM.  */
1496 #define YYPACT_NINF -334
1497 static const yytype_int16 yypact[] =
1498 {
1499      169,    10,    22,  -334,  -334,  -334,  -334,  -334,  -334,  -334,
1500     -334,    82,    99,   133,  -334,   169,   220,    96,  -334,  -334,
1501     -334,   181,   134,   135,   145,  -334,  -334,   220,  -334,  -334,
1502     -334,   220,   170,   205,   183,   212,   213,   220,   237,  -334,
1503     -334,  -334,  -334,   223,   196,   341,   196,   203,  -334,  -334,
1504      200,  -334,   324,  -334,  -334,  -334,  -334,   204,   192,   -30,
1505     -334,  -334,   102,  -334,   125,   208,   332,   256,   324,  -334,
1506      262,   263,   278,   390,  -334,  -334,  -334,  -334,  -334,  -334,
1507     -334,  -334,  -334,  -334,  -334,  -334,   300,   458,   407,   292,
1508      257,  -334,   472,   315,   274,   246,  -334,  -334,   407,   196,
1509      325,   342,  -334,    76,   348,    68,   349,    69,   372,    73,
1510     -334,   351,   381,   359,   364,   375,   386,   432,   486,  -334,
1511     -334,   442,  -334,   486,  -334,   446,   408,     4,  -334,   486,
1512     -334,   462,   255,   449,  -334,   407,  -334,   421,   463,   475,
1513        3,   154,  -334,  -334,  -334,   461,  -334,   435,   484,  -334,
1514      436,  -334,   485,   448,  -334,   488,   128,   452,   273,     7,
1515      263,  -334,   492,   454,  -334,   455,   424,   257,  -334,  -334,
1516       -2,   456,   496,   497,  -334,    27,  -334,   498,   407,   460,
1517       27,   407,    92,    -6,   424,    -5,   459,   500,   464,    65,
1518      466,   467,   489,   204,  -334,  -334,   468,  -334,   469,  -334,
1519      470,   499,  -334,  -334,  -334,   471,   473,   474,   476,   477,
1520      478,   479,   480,   481,   482,   483,   487,   490,   153,  -334,
1521      491,  -334,  -334,   407,   503,   508,   424,   441,   493,    14,
1522      512,   494,  -334,   495,  -334,  -334,   496,  -334,   161,  -334,
1523     -334,   501,   514,   424,   517,  -334,   521,   502,   504,   522,
1524     -334,  -334,    92,  -334,  -334,    80,   204,   204,   204,   121,
1525     -334,  -334,  -334,  -334,  -334,   144,   144,   144,    76,    76,
1526       16,   263,   407,   195,   275,   281,   285,   293,  -334,   273,
1527      525,   505,   506,   510,   509,   162,   163,   407,    88,   531,
1528      373,   193,  -334,   535,   424,   511,   513,   515,  -334,  -334,
1529      531,  -334,   516,   204,  -334,  -334,  -334,   518,   204,   520,
1530     -334,  -334,  -334,  -334,  -334,  -334,   520,  -334,  -334,  -334,
1531     -334,  -334,  -334,  -334,  -334,  -334,  -334,  -334,  -334,  -334,
1532     -334,  -334,  -334,     9,  -334,  -334,   532,   531,   407,   407,
1533     -334,   523,   536,    30,   128,  -334,  -334,  -334,  -334,   524,
1534      424,   531,   424,   128,   204,  -334,   204,  -334,   526,   528,
1535     -334,    23,   128,  -334,  -334,   541,    75,   537,   548,  -334,
1536     -334,   531,   527,   128,   529,  -334,  -334,  -334,   530,   546,
1537      534,  -334,  -334,    75,  -334,   519,    70,    86,   533,    62,
1538     -334,  -334,    30,   128,   531,  -334,   531,  -334,   538,   547,
1539       84,    76,    76,  -334,    76,  -334,    76,  -334,  -334,   555,
1540     -334,   128,   128,  -334,   539,  -334,  -334,  -334,  -334,  -334,
1541       30,  -334,  -334,  -334,  -334
1542 };
1543
1544 /* YYPGOTO[NTERM-NUM].  */
1545 static const yytype_int16 yypgoto[] =
1546 {
1547     -334,  -334,   146,   165,   561,  -334,  -186,  -334,   542,   -28,
1548      392,   396,   402,  -334,  -334,  -334,  -334,  -334,  -334,  -233,
1549     -334,   308,  -334,   -34,  -155,   -44,  -334,   -71,  -334,   -69,
1550      -47,   457,  -334,   -18,   355,  -333,    94,  -294,  -285,  -181,
1551     -264,  -334,   303,   214,  -281,   228,  -334,   507,   248,  -334,
1552      249,  -334,  -103
1553 };
1554
1555 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1556    positive, shift that token.  If negative, reduce the rule which
1557    number is the opposite.  If YYTABLE_NINF, syntax error.  */
1558 #define YYTABLE_NINF -162
1559 static const yytype_int16 yytable[] =
1560 {
1561      146,    89,   120,   248,   121,   222,   353,   260,   100,   167,
1562       68,   370,    94,   182,   142,   143,   124,    88,   144,   286,
1563      375,   130,   182,   340,   112,   183,   220,   104,   359,   382,
1564      171,    21,   105,   312,   313,   316,   143,   317,    68,   144,
1565      395,    22,   380,   362,   125,   284,   170,   120,   310,   142,
1566      143,   249,   120,   144,   138,   185,   172,   373,   120,   171,
1567      410,   184,   296,   145,   185,   139,   133,   221,   127,   360,
1568      304,   305,   306,  -159,   363,   364,   287,   393,   421,   422,
1569      168,   384,   250,   381,   145,   172,   367,    58,   151,   142,
1570      143,   177,   154,   144,   384,   142,   143,   255,   145,   144,
1571      411,    23,   412,   384,   173,   142,   143,   409,   408,   144,
1572      341,   245,   302,   349,   174,   176,   320,   355,    24,   408,
1573      235,   407,   357,   385,   256,   148,   152,   386,   387,   388,
1574      155,   402,    69,    25,   242,   424,   385,   244,   145,   303,
1575      386,   387,   388,   415,   145,   385,   342,   404,   246,   386,
1576      387,   388,    32,   307,   145,   239,   120,   240,   121,   106,
1577      110,    26,   174,   309,   107,   314,   315,   319,   376,   372,
1578      377,   374,     1,   189,   190,   191,   310,    26,     2,   281,
1579      308,    31,   108,    26,   201,    33,   192,   109,   202,    38,
1580       34,    35,    37,     3,     4,     5,     6,     7,     8,     9,
1581       10,    36,    58,    39,    40,    41,    42,    43,    44,    45,
1582       46,    47,   278,   193,   322,   279,   323,    11,    12,    38,
1583      292,  -161,  -160,   293,   338,   339,    57,    48,   321,     2,
1584       49,    61,    63,    39,    40,    41,    42,    43,    44,    45,
1585       46,    47,    70,    28,     3,     4,     5,     6,     7,     8,
1586        9,    10,   347,   103,    71,   293,    65,    96,    66,    28,
1587       49,    95,   101,    29,    30,    28,    67,   137,    11,    12,
1588       39,    40,    41,    42,   170,   111,    45,    46,    47,    29,
1589       30,   113,   114,   403,   405,    29,    30,   171,    39,    40,
1590       41,    42,   204,   132,   324,    67,   325,   116,   416,   417,
1591      326,   418,   327,   419,   328,   122,   329,    39,    40,    41,
1592       42,   126,   330,   172,   331,   205,   206,   207,   208,   209,
1593      210,   127,   211,   212,   213,   214,   215,   216,   217,    73,
1594       74,    75,    76,    77,   131,    78,    79,    80,    81,    82,
1595       83,    84,    85,    86,   140,    87,    73,    74,    75,    76,
1596       77,    65,    78,    79,    80,    81,    82,    83,    84,    85,
1597       86,   141,    87,    98,    99,    39,    40,    41,    42,   147,
1598      150,    45,    46,    47,    39,    40,    41,    42,    73,    74,
1599       75,    76,    77,   345,    78,    79,    80,    81,    82,    83,
1600       84,    85,    86,   153,    87,   118,    74,    75,    76,    77,
1601      157,    78,    79,    80,    81,    82,    83,    84,    85,   119,
1602      156,    87,    73,    74,    75,    76,    77,   158,    78,    79,
1603       80,    81,    82,    83,    84,    85,    86,   160,    87,   227,
1604      228,    75,    76,    77,   161,    78,    79,    80,    81,    82,
1605       83,    84,    85,   229,   162,    87,   118,    74,    75,    76,
1606       77,   163,    78,    79,    80,    81,    82,    83,    84,    85,
1607      285,   164,    87,   123,    74,   165,   166,   169,   175,    78,
1608       79,    80,    81,    82,    83,    84,    85,   129,    74,    87,
1609      178,   194,   179,    78,    79,    80,    81,    82,    83,    84,
1610       85,   118,    74,    87,   180,   195,   197,    78,    79,    80,
1611       81,    82,    83,    84,    85,   196,   198,    87,   199,   200,
1612      184,   223,   224,   226,   236,   237,   170,   241,   243,   252,
1613      185,   259,   282,   264,   254,   257,   258,   283,   261,   262,
1614      263,   288,   265,   295,   266,   267,   297,   268,   269,   270,
1615      271,   272,   273,   274,   275,   298,   301,   280,   276,   333,
1616      343,   277,  -158,   289,   348,   366,   361,   290,   378,   294,
1617      383,   391,   299,   300,   334,   335,   336,   392,   337,   350,
1618      398,   414,   351,   352,   420,   354,    27,   356,   358,   253,
1619      401,   365,   251,   371,   379,   247,   394,   332,   396,   397,
1620      399,   291,    97,   346,   406,     0,   181,   400,   413,   423,
1621        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1622        0,     0,   149
1623 };
1624
1625 #define yypact_value_is_default(Yystate) \
1626   (!!((Yystate) == (-334)))
1627
1628 #define yytable_value_is_error(Yytable_value) \
1629   YYID (0)
1630
1631 static const yytype_int16 yycheck[] =
1632 {
1633      103,    45,    73,   184,    73,   160,   300,   193,    52,     5,
1634       38,   344,    46,    19,    19,    20,    87,    45,    23,     5,
1635      353,    92,    19,   287,    68,    22,    19,    57,    19,   362,
1636       32,    21,    62,   266,   267,    19,    20,   270,    66,    23,
1637      373,    19,    19,   337,    88,   226,    19,   118,    32,    19,
1638       20,    56,   123,    23,    98,    61,    58,   351,   129,    32,
1639      393,    58,   243,    68,    61,    99,    94,    60,    64,    60,
1640      256,   257,   258,    59,   338,   339,    62,   371,   411,   412,
1641      127,    19,   185,    60,    68,    58,    56,    19,    19,    19,
1642       20,   135,    19,    23,    19,    19,    20,    32,    68,    23,
1643      394,    19,   396,    19,   132,    19,    20,   392,   389,    23,
1644       22,    19,    32,   294,   132,   133,   271,   303,    19,   400,
1645      167,    59,   308,    61,    59,    57,    57,    65,    66,    67,
1646       57,    61,    38,     0,   178,   420,    61,   181,    68,    59,
1647       65,    66,    67,    59,    68,    61,    58,    61,    56,    65,
1648       66,    67,    56,    32,    68,   173,   227,   175,   227,    57,
1649       66,    15,   180,    19,    62,   268,   269,   270,   354,   350,
1650      356,   352,     3,    19,    20,    21,    32,    31,     9,   223,
1651       59,    16,    57,    37,    56,     4,    32,    62,    60,    19,
1652       56,    56,    27,    24,    25,    26,    27,    28,    29,    30,
1653       31,    56,    19,    33,    34,    35,    36,    37,    38,    39,
1654       40,    41,    59,    59,    19,    62,    21,    48,    49,    19,
1655       59,    59,    59,    62,    62,    62,    21,    57,   272,     9,
1656       60,    19,    19,    33,    34,    35,    36,    37,    38,    39,
1657       40,    41,    19,    15,    24,    25,    26,    27,    28,    29,
1658       30,    31,    59,    61,    58,    62,    19,    57,    21,    31,
1659       60,    58,    58,    15,    15,    37,    58,    21,    48,    49,
1660       33,    34,    35,    36,    19,    19,    39,    40,    41,    31,
1661       31,    19,    19,   386,   387,    37,    37,    32,    33,    34,
1662       35,    36,    19,    19,    19,    58,    21,    19,   401,   402,
1663       19,   404,    21,   406,    19,     5,    21,    33,    34,    35,
1664       36,    19,    19,    58,    21,    42,    43,    44,    45,    46,
1665       47,    64,    49,    50,    51,    52,    53,    54,    55,     5,
1666        6,     7,     8,     9,    19,    11,    12,    13,    14,    15,
1667       16,    17,    18,    19,    19,    21,     5,     6,     7,     8,
1668        9,    19,    11,    12,    13,    14,    15,    16,    17,    18,
1669       19,    19,    21,    39,    40,    33,    34,    35,    36,    21,
1670       21,    39,    40,    41,    33,    34,    35,    36,     5,     6,
1671        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1672       17,    18,    19,    21,    21,     5,     6,     7,     8,     9,
1673       19,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1674       59,    21,     5,     6,     7,     8,     9,    58,    11,    12,
1675       13,    14,    15,    16,    17,    18,    19,    63,    21,     5,
1676        6,     7,     8,     9,    59,    11,    12,    13,    14,    15,
1677       16,    17,    18,    19,    58,    21,     5,     6,     7,     8,
1678        9,    19,    11,    12,    13,    14,    15,    16,    17,    18,
1679       19,    19,    21,     5,     6,    19,    58,     5,    19,    11,
1680       12,    13,    14,    15,    16,    17,    18,     5,     6,    21,
1681       59,    20,    19,    11,    12,    13,    14,    15,    16,    17,
1682       18,     5,     6,    21,    19,    60,    60,    11,    12,    13,
1683       14,    15,    16,    17,    18,    21,    21,    21,    60,    21,
1684       58,    19,    58,    58,    58,    19,    19,    19,    58,    19,
1685       61,    32,    19,    24,    60,    59,    59,    19,    60,    60,
1686       60,    19,    61,    19,    61,    61,    19,    61,    61,    61,
1687       61,    61,    61,    61,    61,    24,    24,    56,    61,    24,
1688       19,    61,    59,    59,    19,    19,    24,    62,    32,    58,
1689       19,    24,    60,    59,    59,    59,    56,    19,    59,    58,
1690       24,    24,    59,    58,    19,    59,    15,    59,    58,   187,
1691       61,    58,   186,    59,    56,   183,    59,   279,    59,    59,
1692       56,   236,    50,   290,    61,    -1,   139,   383,    60,    60,
1693       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1694       -1,    -1,   105
1695 };
1696
1697 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1698    symbol of state STATE-NUM.  */
1699 static const yytype_uint8 yystos[] =
1700 {
1701        0,     3,     9,    24,    25,    26,    27,    28,    29,    30,
1702       31,    48,    49,    70,    71,    72,    73,    74,   114,   117,
1703      119,    21,    19,    19,    19,     0,    71,    73,   114,   117,
1704      119,    72,    56,     4,    56,    56,    56,    72,    19,    33,
1705       34,    35,    36,    37,    38,    39,    40,    41,    57,    60,
1706       76,    77,    78,    82,    83,    85,   105,    21,    19,   115,
1707      116,    19,   120,    19,   118,    19,    21,    58,    78,   105,
1708       19,    58,    92,     5,     6,     7,     8,     9,    11,    12,
1709       13,    14,    15,    16,    17,    18,    19,    21,    78,    94,
1710       95,    96,    97,    98,    92,    58,    57,    77,    39,    40,
1711       94,    58,    75,    61,    57,    62,    57,    62,    57,    62,
1712      105,    19,    94,    19,    19,    93,    19,    91,     5,    19,
1713       96,    98,     5,     5,    96,    94,    19,    64,    99,     5,
1714       96,    19,    19,    78,   100,   101,   102,    21,    94,    92,
1715       19,    19,    19,    20,    23,    68,   121,    21,    57,   116,
1716       21,    19,    57,    21,    19,    57,    59,    19,    58,    86,
1717       63,    59,    58,    19,    19,    19,    58,     5,    99,     5,
1718       19,    32,    58,    78,   102,    19,   102,    94,    59,    19,
1719       19,   100,    19,    22,    58,    61,    79,    80,    81,    19,
1720       20,    21,    32,    59,    20,    60,    21,    60,    21,    60,
1721       21,    56,    60,   104,    19,    42,    43,    44,    45,    46,
1722       47,    49,    50,    51,    52,    53,    54,    55,    87,    90,
1723       19,    60,    93,    19,    58,    84,    58,     5,     6,    19,
1724       94,   108,   109,   110,   111,    99,    58,    19,   103,   102,
1725      102,    19,    94,    58,    94,    19,    56,    81,   108,    56,
1726      121,    80,    19,    79,    60,    32,    59,    59,    59,    32,
1727       75,    60,    60,    60,    24,    61,    61,    61,    61,    61,
1728       61,    61,    61,    61,    61,    61,    61,    61,    59,    62,
1729       56,    94,    19,    19,   108,    19,     5,    62,    19,    59,
1730       62,   103,    59,    62,    58,    19,   108,    19,    24,    60,
1731       59,    24,    32,    59,    75,    75,    75,    32,    59,    19,
1732       32,    88,    88,    88,   121,   121,    19,    88,    89,   121,
1733       93,    94,    19,    21,    19,    21,    19,    21,    19,    21,
1734       19,    21,    90,    24,    59,    59,    56,    59,    62,    62,
1735      109,    22,    58,    19,   106,    10,   111,    59,    19,   108,
1736       58,    59,    58,   106,    59,    75,    59,    75,    58,    19,
1737       60,    24,   106,   109,   109,    58,    19,    56,   107,   121,
1738      104,    59,   108,   106,   108,   104,    75,    75,    32,    56,
1739       19,    60,   104,    19,    19,    61,    65,    66,    67,   112,
1740      113,    24,    19,   106,    59,   104,    59,    59,    24,    56,
1741      112,    61,    61,   121,    61,   121,    61,    59,   113,   107,
1742      104,   106,   106,    60,    24,    59,   121,   121,   121,   121,
1743       19,   104,   104,    60,   107
1744 };
1745
1746 #define yyerrok         (yyerrstatus = 0)
1747 #define yyclearin       (yychar = YYEMPTY)
1748 #define YYEMPTY         (-2)
1749 #define YYEOF           0
1750
1751 #define YYACCEPT        goto yyacceptlab
1752 #define YYABORT         goto yyabortlab
1753 #define YYERROR         goto yyerrorlab
1754
1755
1756 /* Like YYERROR except do call yyerror.  This remains here temporarily
1757    to ease the transition to the new meaning of YYERROR, for GCC.
1758    Once GCC version 2 has supplanted version 1, this can go.  However,
1759    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
1760    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1761    discussed.  */
1762
1763 #define YYFAIL          goto yyerrlab
1764 #if defined YYFAIL
1765   /* This is here to suppress warnings from the GCC cpp's
1766      -Wunused-macros.  Normally we don't worry about that warning, but
1767      some users do, and we want to make it easy for users to remove
1768      YYFAIL uses, which will produce warnings from Bison 2.5.  */
1769 #endif
1770
1771 #define YYRECOVERING()  (!!yyerrstatus)
1772
1773 #define YYBACKUP(Token, Value)                                  \
1774 do                                                              \
1775   if (yychar == YYEMPTY)                                        \
1776     {                                                           \
1777       yychar = (Token);                                         \
1778       yylval = (Value);                                         \
1779       YYPOPSTACK (yylen);                                       \
1780       yystate = *yyssp;                                         \
1781       goto yybackup;                                            \
1782     }                                                           \
1783   else                                                          \
1784     {                                                           \
1785       yyerror (YY_("syntax error: cannot back up")); \
1786       YYERROR;                                                  \
1787     }                                                           \
1788 while (YYID (0))
1789
1790 /* Error token number */
1791 #define YYTERROR        1
1792 #define YYERRCODE       256
1793
1794
1795 /* This macro is provided for backward compatibility. */
1796 #ifndef YY_LOCATION_PRINT
1797 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1798 #endif
1799
1800
1801 /* YYLEX -- calling `yylex' with the right arguments.  */
1802 #ifdef YYLEX_PARAM
1803 # define YYLEX yylex (YYLEX_PARAM)
1804 #else
1805 # define YYLEX yylex ()
1806 #endif
1807
1808 /* Enable debugging if requested.  */
1809 #if YYDEBUG
1810
1811 # ifndef YYFPRINTF
1812 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1813 #  define YYFPRINTF fprintf
1814 # endif
1815
1816 # define YYDPRINTF(Args)                        \
1817 do {                                            \
1818   if (yydebug)                                  \
1819     YYFPRINTF Args;                             \
1820 } while (YYID (0))
1821
1822 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1823 do {                                                                      \
1824   if (yydebug)                                                            \
1825     {                                                                     \
1826       YYFPRINTF (stderr, "%s ", Title);                                   \
1827       yy_symbol_print (stderr,                                            \
1828                   Type, Value); \
1829       YYFPRINTF (stderr, "\n");                                           \
1830     }                                                                     \
1831 } while (YYID (0))
1832
1833
1834 /*--------------------------------.
1835 | Print this symbol on YYOUTPUT.  |
1836 `--------------------------------*/
1837
1838 /*ARGSUSED*/
1839 #if (defined __STDC__ || defined __C99__FUNC__ \
1840      || defined __cplusplus || defined _MSC_VER)
1841 static void
1842 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1843 #else
1844 static void
1845 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1846     FILE *yyoutput;
1847     int yytype;
1848     YYSTYPE const * const yyvaluep;
1849 #endif
1850 {
1851   FILE *yyo = yyoutput;
1852   YYUSE (yyo);
1853   if (!yyvaluep)
1854     return;
1855 # ifdef YYPRINT
1856   if (yytype < YYNTOKENS)
1857     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1858 # else
1859   YYUSE (yyoutput);
1860 # endif
1861   switch (yytype)
1862     {
1863       default:
1864         break;
1865     }
1866 }
1867
1868
1869 /*--------------------------------.
1870 | Print this symbol on YYOUTPUT.  |
1871 `--------------------------------*/
1872
1873 #if (defined __STDC__ || defined __C99__FUNC__ \
1874      || defined __cplusplus || defined _MSC_VER)
1875 static void
1876 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1877 #else
1878 static void
1879 yy_symbol_print (yyoutput, yytype, yyvaluep)
1880     FILE *yyoutput;
1881     int yytype;
1882     YYSTYPE const * const yyvaluep;
1883 #endif
1884 {
1885   if (yytype < YYNTOKENS)
1886     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1887   else
1888     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1889
1890   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1891   YYFPRINTF (yyoutput, ")");
1892 }
1893
1894 /*------------------------------------------------------------------.
1895 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1896 | TOP (included).                                                   |
1897 `------------------------------------------------------------------*/
1898
1899 #if (defined __STDC__ || defined __C99__FUNC__ \
1900      || defined __cplusplus || defined _MSC_VER)
1901 static void
1902 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1903 #else
1904 static void
1905 yy_stack_print (yybottom, yytop)
1906     yytype_int16 *yybottom;
1907     yytype_int16 *yytop;
1908 #endif
1909 {
1910   YYFPRINTF (stderr, "Stack now");
1911   for (; yybottom <= yytop; yybottom++)
1912     {
1913       int yybot = *yybottom;
1914       YYFPRINTF (stderr, " %d", yybot);
1915     }
1916   YYFPRINTF (stderr, "\n");
1917 }
1918
1919 # define YY_STACK_PRINT(Bottom, Top)                            \
1920 do {                                                            \
1921   if (yydebug)                                                  \
1922     yy_stack_print ((Bottom), (Top));                           \
1923 } while (YYID (0))
1924
1925
1926 /*------------------------------------------------.
1927 | Report that the YYRULE is going to be reduced.  |
1928 `------------------------------------------------*/
1929
1930 #if (defined __STDC__ || defined __C99__FUNC__ \
1931      || defined __cplusplus || defined _MSC_VER)
1932 static void
1933 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1934 #else
1935 static void
1936 yy_reduce_print (yyvsp, yyrule)
1937     YYSTYPE *yyvsp;
1938     int yyrule;
1939 #endif
1940 {
1941   int yynrhs = yyr2[yyrule];
1942   int yyi;
1943   unsigned long int yylno = yyrline[yyrule];
1944   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1945              yyrule - 1, yylno);
1946   /* The symbols being reduced.  */
1947   for (yyi = 0; yyi < yynrhs; yyi++)
1948     {
1949       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1950       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1951                        &(yyvsp[(yyi + 1) - (yynrhs)])
1952                                        );
1953       YYFPRINTF (stderr, "\n");
1954     }
1955 }
1956
1957 # define YY_REDUCE_PRINT(Rule)          \
1958 do {                                    \
1959   if (yydebug)                          \
1960     yy_reduce_print (yyvsp, Rule); \
1961 } while (YYID (0))
1962
1963 /* Nonzero means print parse trace.  It is left uninitialized so that
1964    multiple parsers can coexist.  */
1965 int yydebug;
1966 #else /* !YYDEBUG */
1967 # define YYDPRINTF(Args)
1968 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1969 # define YY_STACK_PRINT(Bottom, Top)
1970 # define YY_REDUCE_PRINT(Rule)
1971 #endif /* !YYDEBUG */
1972
1973
1974 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1975 #ifndef YYINITDEPTH
1976 # define YYINITDEPTH 200
1977 #endif
1978
1979 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1980    if the built-in stack extension method is used).
1981
1982    Do not make this value too large; the results are undefined if
1983    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1984    evaluated with infinite-precision integer arithmetic.  */
1985
1986 #ifndef YYMAXDEPTH
1987 # define YYMAXDEPTH 10000
1988 #endif
1989
1990
1991 #if YYERROR_VERBOSE
1992
1993 # ifndef yystrlen
1994 #  if defined __GLIBC__ && defined _STRING_H
1995 #   define yystrlen strlen
1996 #  else
1997 /* Return the length of YYSTR.  */
1998 #if (defined __STDC__ || defined __C99__FUNC__ \
1999      || defined __cplusplus || defined _MSC_VER)
2000 static YYSIZE_T
2001 yystrlen (const char *yystr)
2002 #else
2003 static YYSIZE_T
2004 yystrlen (yystr)
2005     const char *yystr;
2006 #endif
2007 {
2008   YYSIZE_T yylen;
2009   for (yylen = 0; yystr[yylen]; yylen++)
2010     continue;
2011   return yylen;
2012 }
2013 #  endif
2014 # endif
2015
2016 # ifndef yystpcpy
2017 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2018 #   define yystpcpy stpcpy
2019 #  else
2020 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2021    YYDEST.  */
2022 #if (defined __STDC__ || defined __C99__FUNC__ \
2023      || defined __cplusplus || defined _MSC_VER)
2024 static char *
2025 yystpcpy (char *yydest, const char *yysrc)
2026 #else
2027 static char *
2028 yystpcpy (yydest, yysrc)
2029     char *yydest;
2030     const char *yysrc;
2031 #endif
2032 {
2033   char *yyd = yydest;
2034   const char *yys = yysrc;
2035
2036   while ((*yyd++ = *yys++) != '\0')
2037     continue;
2038
2039   return yyd - 1;
2040 }
2041 #  endif
2042 # endif
2043
2044 # ifndef yytnamerr
2045 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2046    quotes and backslashes, so that it's suitable for yyerror.  The
2047    heuristic is that double-quoting is unnecessary unless the string
2048    contains an apostrophe, a comma, or backslash (other than
2049    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
2050    null, do not copy; instead, return the length of what the result
2051    would have been.  */
2052 static YYSIZE_T
2053 yytnamerr (char *yyres, const char *yystr)
2054 {
2055   if (*yystr == '"')
2056     {
2057       YYSIZE_T yyn = 0;
2058       char const *yyp = yystr;
2059
2060       for (;;)
2061         switch (*++yyp)
2062           {
2063           case '\'':
2064           case ',':
2065             goto do_not_strip_quotes;
2066
2067           case '\\':
2068             if (*++yyp != '\\')
2069               goto do_not_strip_quotes;
2070             /* Fall through.  */
2071           default:
2072             if (yyres)
2073               yyres[yyn] = *yyp;
2074             yyn++;
2075             break;
2076
2077           case '"':
2078             if (yyres)
2079               yyres[yyn] = '\0';
2080             return yyn;
2081           }
2082     do_not_strip_quotes: ;
2083     }
2084
2085   if (! yyres)
2086     return yystrlen (yystr);
2087
2088   return yystpcpy (yyres, yystr) - yyres;
2089 }
2090 # endif
2091
2092 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
2093    about the unexpected token YYTOKEN for the state stack whose top is
2094    YYSSP.
2095
2096    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
2097    not large enough to hold the message.  In that case, also set
2098    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
2099    required number of bytes is too large to store.  */
2100 static int
2101 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
2102                 yytype_int16 *yyssp, int yytoken)
2103 {
2104   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
2105   YYSIZE_T yysize = yysize0;
2106   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2107   /* Internationalized format string. */
2108   const char *yyformat = YY_NULL;
2109   /* Arguments of yyformat. */
2110   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2111   /* Number of reported tokens (one for the "unexpected", one per
2112      "expected"). */
2113   int yycount = 0;
2114
2115   /* There are many possibilities here to consider:
2116      - Assume YYFAIL is not used.  It's too flawed to consider.  See
2117        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
2118        for details.  YYERROR is fine as it does not invoke this
2119        function.
2120      - If this state is a consistent state with a default action, then
2121        the only way this function was invoked is if the default action
2122        is an error action.  In that case, don't check for expected
2123        tokens because there are none.
2124      - The only way there can be no lookahead present (in yychar) is if
2125        this state is a consistent state with a default action.  Thus,
2126        detecting the absence of a lookahead is sufficient to determine
2127        that there is no unexpected or expected token to report.  In that
2128        case, just report a simple "syntax error".
2129      - Don't assume there isn't a lookahead just because this state is a
2130        consistent state with a default action.  There might have been a
2131        previous inconsistent state, consistent state with a non-default
2132        action, or user semantic action that manipulated yychar.
2133      - Of course, the expected token list depends on states to have
2134        correct lookahead information, and it depends on the parser not
2135        to perform extra reductions after fetching a lookahead from the
2136        scanner and before detecting a syntax error.  Thus, state merging
2137        (from LALR or IELR) and default reductions corrupt the expected
2138        token list.  However, the list is correct for canonical LR with
2139        one exception: it will still contain any token that will not be
2140        accepted due to an error action in a later state.
2141   */
2142   if (yytoken != YYEMPTY)
2143     {
2144       int yyn = yypact[*yyssp];
2145       yyarg[yycount++] = yytname[yytoken];
2146       if (!yypact_value_is_default (yyn))
2147         {
2148           /* Start YYX at -YYN if negative to avoid negative indexes in
2149              YYCHECK.  In other words, skip the first -YYN actions for
2150              this state because they are default actions.  */
2151           int yyxbegin = yyn < 0 ? -yyn : 0;
2152           /* Stay within bounds of both yycheck and yytname.  */
2153           int yychecklim = YYLAST - yyn + 1;
2154           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2155           int yyx;
2156
2157           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2158             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2159                 && !yytable_value_is_error (yytable[yyx + yyn]))
2160               {
2161                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2162                   {
2163                     yycount = 1;
2164                     yysize = yysize0;
2165                     break;
2166                   }
2167                 yyarg[yycount++] = yytname[yyx];
2168                 {
2169                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
2170                   if (! (yysize <= yysize1
2171                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2172                     return 2;
2173                   yysize = yysize1;
2174                 }
2175               }
2176         }
2177     }
2178
2179   switch (yycount)
2180     {
2181 # define YYCASE_(N, S)                      \
2182       case N:                               \
2183         yyformat = S;                       \
2184       break
2185       YYCASE_(0, YY_("syntax error"));
2186       YYCASE_(1, YY_("syntax error, unexpected %s"));
2187       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2188       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2189       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2190       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2191 # undef YYCASE_
2192     }
2193
2194   {
2195     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2196     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2197       return 2;
2198     yysize = yysize1;
2199   }
2200
2201   if (*yymsg_alloc < yysize)
2202     {
2203       *yymsg_alloc = 2 * yysize;
2204       if (! (yysize <= *yymsg_alloc
2205              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2206         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2207       return 1;
2208     }
2209
2210   /* Avoid sprintf, as that infringes on the user's name space.
2211      Don't have undefined behavior even if the translation
2212      produced a string with the wrong number of "%s"s.  */
2213   {
2214     char *yyp = *yymsg;
2215     int yyi = 0;
2216     while ((*yyp = *yyformat) != '\0')
2217       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2218         {
2219           yyp += yytnamerr (yyp, yyarg[yyi++]);
2220           yyformat += 2;
2221         }
2222       else
2223         {
2224           yyp++;
2225           yyformat++;
2226         }
2227   }
2228   return 0;
2229 }
2230 #endif /* YYERROR_VERBOSE */
2231
2232 /*-----------------------------------------------.
2233 | Release the memory associated to this symbol.  |
2234 `-----------------------------------------------*/
2235
2236 /*ARGSUSED*/
2237 #if (defined __STDC__ || defined __C99__FUNC__ \
2238      || defined __cplusplus || defined _MSC_VER)
2239 static void
2240 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2241 #else
2242 static void
2243 yydestruct (yymsg, yytype, yyvaluep)
2244     const char *yymsg;
2245     int yytype;
2246     YYSTYPE *yyvaluep;
2247 #endif
2248 {
2249   YYUSE (yyvaluep);
2250
2251   if (!yymsg)
2252     yymsg = "Deleting";
2253   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2254
2255   switch (yytype)
2256     {
2257
2258       default:
2259         break;
2260     }
2261 }
2262
2263
2264
2265
2266 /* The lookahead symbol.  */
2267 int yychar;
2268
2269
2270 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2271 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2272 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
2273 #endif
2274 #ifndef YY_INITIAL_VALUE
2275 # define YY_INITIAL_VALUE(Value) /* Nothing. */
2276 #endif
2277
2278 /* The semantic value of the lookahead symbol.  */
2279 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
2280
2281 /* Number of syntax errors so far.  */
2282 int yynerrs;
2283
2284
2285 /*----------.
2286 | yyparse.  |
2287 `----------*/
2288
2289 #ifdef YYPARSE_PARAM
2290 #if (defined __STDC__ || defined __C99__FUNC__ \
2291      || defined __cplusplus || defined _MSC_VER)
2292 int
2293 yyparse (void *YYPARSE_PARAM)
2294 #else
2295 int
2296 yyparse (YYPARSE_PARAM)
2297     void *YYPARSE_PARAM;
2298 #endif
2299 #else /* ! YYPARSE_PARAM */
2300 #if (defined __STDC__ || defined __C99__FUNC__ \
2301      || defined __cplusplus || defined _MSC_VER)
2302 int
2303 yyparse (void)
2304 #else
2305 int
2306 yyparse ()
2307
2308 #endif
2309 #endif
2310 {
2311     int yystate;
2312     /* Number of tokens to shift before error messages enabled.  */
2313     int yyerrstatus;
2314
2315     /* The stacks and their tools:
2316        `yyss': related to states.
2317        `yyvs': related to semantic values.
2318
2319        Refer to the stacks through separate pointers, to allow yyoverflow
2320        to reallocate them elsewhere.  */
2321
2322     /* The state stack.  */
2323     yytype_int16 yyssa[YYINITDEPTH];
2324     yytype_int16 *yyss;
2325     yytype_int16 *yyssp;
2326
2327     /* The semantic value stack.  */
2328     YYSTYPE yyvsa[YYINITDEPTH];
2329     YYSTYPE *yyvs;
2330     YYSTYPE *yyvsp;
2331
2332     YYSIZE_T yystacksize;
2333
2334   int yyn;
2335   int yyresult;
2336   /* Lookahead token as an internal (translated) token number.  */
2337   int yytoken = 0;
2338   /* The variables used to return semantic value and location from the
2339      action routines.  */
2340   YYSTYPE yyval;
2341
2342 #if YYERROR_VERBOSE
2343   /* Buffer for error messages, and its allocated size.  */
2344   char yymsgbuf[128];
2345   char *yymsg = yymsgbuf;
2346   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2347 #endif
2348
2349 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
2350
2351   /* The number of symbols on the RHS of the reduced rule.
2352      Keep to zero when no symbol should be popped.  */
2353   int yylen = 0;
2354
2355   yyssp = yyss = yyssa;
2356   yyvsp = yyvs = yyvsa;
2357   yystacksize = YYINITDEPTH;
2358
2359   YYDPRINTF ((stderr, "Starting parse\n"));
2360
2361   yystate = 0;
2362   yyerrstatus = 0;
2363   yynerrs = 0;
2364   yychar = YYEMPTY; /* Cause a token to be read.  */
2365   goto yysetstate;
2366
2367 /*------------------------------------------------------------.
2368 | yynewstate -- Push a new state, which is found in yystate.  |
2369 `------------------------------------------------------------*/
2370  yynewstate:
2371   /* In all cases, when you get here, the value and location stacks
2372      have just been pushed.  So pushing a state here evens the stacks.  */
2373   yyssp++;
2374
2375  yysetstate:
2376   *yyssp = yystate;
2377
2378   if (yyss + yystacksize - 1 <= yyssp)
2379     {
2380       /* Get the current used size of the three stacks, in elements.  */
2381       YYSIZE_T yysize = yyssp - yyss + 1;
2382
2383 #ifdef yyoverflow
2384       {
2385         /* Give user a chance to reallocate the stack.  Use copies of
2386            these so that the &'s don't force the real ones into
2387            memory.  */
2388         YYSTYPE *yyvs1 = yyvs;
2389         yytype_int16 *yyss1 = yyss;
2390
2391         /* Each stack pointer address is followed by the size of the
2392            data in use in that stack, in bytes.  This used to be a
2393            conditional around just the two extra args, but that might
2394            be undefined if yyoverflow is a macro.  */
2395         yyoverflow (YY_("memory exhausted"),
2396                     &yyss1, yysize * sizeof (*yyssp),
2397                     &yyvs1, yysize * sizeof (*yyvsp),
2398                     &yystacksize);
2399
2400         yyss = yyss1;
2401         yyvs = yyvs1;
2402       }
2403 #else /* no yyoverflow */
2404 # ifndef YYSTACK_RELOCATE
2405       goto yyexhaustedlab;
2406 # else
2407       /* Extend the stack our own way.  */
2408       if (YYMAXDEPTH <= yystacksize)
2409         goto yyexhaustedlab;
2410       yystacksize *= 2;
2411       if (YYMAXDEPTH < yystacksize)
2412         yystacksize = YYMAXDEPTH;
2413
2414       {
2415         yytype_int16 *yyss1 = yyss;
2416         union yyalloc *yyptr =
2417           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2418         if (! yyptr)
2419           goto yyexhaustedlab;
2420         YYSTACK_RELOCATE (yyss_alloc, yyss);
2421         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2422 #  undef YYSTACK_RELOCATE
2423         if (yyss1 != yyssa)
2424           YYSTACK_FREE (yyss1);
2425       }
2426 # endif
2427 #endif /* no yyoverflow */
2428
2429       yyssp = yyss + yysize - 1;
2430       yyvsp = yyvs + yysize - 1;
2431
2432       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2433                   (unsigned long int) yystacksize));
2434
2435       if (yyss + yystacksize - 1 <= yyssp)
2436         YYABORT;
2437     }
2438
2439   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2440
2441   if (yystate == YYFINAL)
2442     YYACCEPT;
2443
2444   goto yybackup;
2445
2446 /*-----------.
2447 | yybackup.  |
2448 `-----------*/
2449 yybackup:
2450
2451   /* Do appropriate processing given the current state.  Read a
2452      lookahead token if we need one and don't already have one.  */
2453
2454   /* First try to decide what to do without reference to lookahead token.  */
2455   yyn = yypact[yystate];
2456   if (yypact_value_is_default (yyn))
2457     goto yydefault;
2458
2459   /* Not known => get a lookahead token if don't already have one.  */
2460
2461   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
2462   if (yychar == YYEMPTY)
2463     {
2464       YYDPRINTF ((stderr, "Reading a token: "));
2465       yychar = YYLEX;
2466     }
2467
2468   if (yychar <= YYEOF)
2469     {
2470       yychar = yytoken = YYEOF;
2471       YYDPRINTF ((stderr, "Now at end of input.\n"));
2472     }
2473   else
2474     {
2475       yytoken = YYTRANSLATE (yychar);
2476       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2477     }
2478
2479   /* If the proper action on seeing token YYTOKEN is to reduce or to
2480      detect an error, take that action.  */
2481   yyn += yytoken;
2482   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2483     goto yydefault;
2484   yyn = yytable[yyn];
2485   if (yyn <= 0)
2486     {
2487       if (yytable_value_is_error (yyn))
2488         goto yyerrlab;
2489       yyn = -yyn;
2490       goto yyreduce;
2491     }
2492
2493   /* Count tokens shifted since error; after three, turn off error
2494      status.  */
2495   if (yyerrstatus)
2496     yyerrstatus--;
2497
2498   /* Shift the lookahead token.  */
2499   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2500
2501   /* Discard the shifted token.  */
2502   yychar = YYEMPTY;
2503
2504   yystate = yyn;
2505   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2506   *++yyvsp = yylval;
2507   YY_IGNORE_MAYBE_UNINITIALIZED_END
2508
2509   goto yynewstate;
2510
2511
2512 /*-----------------------------------------------------------.
2513 | yydefault -- do the default action for the current state.  |
2514 `-----------------------------------------------------------*/
2515 yydefault:
2516   yyn = yydefact[yystate];
2517   if (yyn == 0)
2518     goto yyerrlab;
2519   goto yyreduce;
2520
2521
2522 /*-----------------------------.
2523 | yyreduce -- Do a reduction.  |
2524 `-----------------------------*/
2525 yyreduce:
2526   /* yyn is the number of a rule to reduce with.  */
2527   yylen = yyr2[yyn];
2528
2529   /* If YYLEN is nonzero, implement the default value of the action:
2530      `$$ = $1'.
2531
2532      Otherwise, the following line sets YYVAL to garbage.
2533      This behavior is undocumented and Bison
2534      users should not rely upon it.  Assigning to YYVAL
2535      unconditionally makes the parser a bit smaller, and it avoids a
2536      GCC warning that YYVAL may be used uninitialized.  */
2537   yyval = yyvsp[1-yylen];
2538
2539
2540   YY_REDUCE_PRINT (yyn);
2541   switch (yyn)
2542     {
2543         case 2:
2544 /* Line 1792 of yacc.c  */
2545 #line 713 "parse.y"
2546     { ; }
2547     break;
2548
2549   case 3:
2550 /* Line 1792 of yacc.c  */
2551 #line 714 "parse.y"
2552     { ; }
2553     break;
2554
2555   case 4:
2556 /* Line 1792 of yacc.c  */
2557 #line 715 "parse.y"
2558     { ; }
2559     break;
2560
2561   case 5:
2562 /* Line 1792 of yacc.c  */
2563 #line 716 "parse.y"
2564     { ; }
2565     break;
2566
2567   case 6:
2568 /* Line 1792 of yacc.c  */
2569 #line 719 "parse.y"
2570     {
2571                         Node *node = node_new (CCODE_NODE,
2572                                                "cctype", C_CCODE,
2573                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2574                                                "line_no", ccode_line,
2575                                                NULL);
2576                         nodes = g_list_append(nodes,node);
2577                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2578                                         }
2579     break;
2580
2581   case 7:
2582 /* Line 1792 of yacc.c  */
2583 #line 728 "parse.y"
2584     {
2585                         Node *node = node_new (CCODE_NODE,
2586                                                "cctype", AD_CCODE,
2587                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2588                                                "line_no", ccode_line,
2589                                                NULL);
2590                         nodes = g_list_append(nodes,node);
2591                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2592                                         }
2593     break;
2594
2595   case 8:
2596 /* Line 1792 of yacc.c  */
2597 #line 737 "parse.y"
2598     {
2599                         Node *node = node_new (CCODE_NODE,
2600                                                "cctype", H_CCODE,
2601                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2602                                                "line_no", ccode_line,
2603                                                NULL);
2604                         nodes = g_list_append(nodes,node);
2605                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2606                                         }
2607     break;
2608
2609   case 9:
2610 /* Line 1792 of yacc.c  */
2611 #line 746 "parse.y"
2612     {
2613                         Node *node = node_new (CCODE_NODE,
2614                                                "cctype", HT_CCODE,
2615                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2616                                                "line_no", ccode_line,
2617                                                NULL);
2618                         nodes = g_list_append(nodes,node);
2619                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2620                                         }
2621     break;
2622
2623   case 10:
2624 /* Line 1792 of yacc.c  */
2625 #line 755 "parse.y"
2626     {
2627                         Node *node = node_new (CCODE_NODE,
2628                                                "cctype", PH_CCODE,
2629                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2630                                                "line_no", ccode_line,
2631                                                NULL);
2632                         nodes = g_list_append(nodes,node);
2633                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2634                                         }
2635     break;
2636
2637   case 11:
2638 /* Line 1792 of yacc.c  */
2639 #line 764 "parse.y"
2640     {
2641                         Node *node = node_new (CCODE_NODE,
2642                                                "cctype", A_CCODE,
2643                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2644                                                "line_no", ccode_line,
2645                                                NULL);
2646                         nodes = g_list_append(nodes,node);
2647                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2648                                         }
2649     break;
2650
2651   case 12:
2652 /* Line 1792 of yacc.c  */
2653 #line 773 "parse.y"
2654     {
2655                         Node *node = node_new (CCODE_NODE,
2656                                                "cctype", AT_CCODE,
2657                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2658                                                "line_no", ccode_line,
2659                                                NULL);
2660                         nodes = g_list_append(nodes,node);
2661                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2662                                         }
2663     break;
2664
2665   case 13:
2666 /* Line 1792 of yacc.c  */
2667 #line 782 "parse.y"
2668     {
2669                         Node *node = node_new (CCODE_NODE,
2670                                                "cctype", CT_CCODE,
2671                                                "cbuf:steal", ((yyvsp[(1) - (1)].cbuf))->str,
2672                                                "line_no", ccode_line,
2673                                                NULL);
2674                         nodes = g_list_append(nodes,node);
2675                         g_string_free((yyvsp[(1) - (1)].cbuf),FALSE);
2676                                         }
2677     break;
2678
2679   case 14:
2680 /* Line 1792 of yacc.c  */
2681 #line 793 "parse.y"
2682     { ; }
2683     break;
2684
2685   case 15:
2686 /* Line 1792 of yacc.c  */
2687 #line 794 "parse.y"
2688     { ; }
2689     break;
2690
2691   case 16:
2692 /* Line 1792 of yacc.c  */
2693 #line 795 "parse.y"
2694     { ; }
2695     break;
2696
2697   case 17:
2698 /* Line 1792 of yacc.c  */
2699 #line 796 "parse.y"
2700     { ; }
2701     break;
2702
2703   case 18:
2704 /* Line 1792 of yacc.c  */
2705 #line 797 "parse.y"
2706     { ; }
2707     break;
2708
2709   case 19:
2710 /* Line 1792 of yacc.c  */
2711 #line 798 "parse.y"
2712     { ; }
2713     break;
2714
2715   case 20:
2716 /* Line 1792 of yacc.c  */
2717 #line 799 "parse.y"
2718     { ; }
2719     break;
2720
2721   case 21:
2722 /* Line 1792 of yacc.c  */
2723 #line 800 "parse.y"
2724     { ; }
2725     break;
2726
2727   case 22:
2728 /* Line 1792 of yacc.c  */
2729 #line 803 "parse.y"
2730     {
2731                         ((Class *)class)->nodes = class_nodes;
2732                         class_nodes = NULL;
2733                         nodes = g_list_append(nodes,class);
2734                                                 }
2735     break;
2736
2737   case 23:
2738 /* Line 1792 of yacc.c  */
2739 #line 808 "parse.y"
2740     {
2741                         ((Class *)class)->nodes = NULL;
2742                         class_nodes = NULL;
2743                         nodes = g_list_append(nodes,class);
2744                                                 }
2745     break;
2746
2747   case 24:
2748 /* Line 1792 of yacc.c  */
2749 #line 815 "parse.y"
2750     {
2751                         class = node_new (CLASS_NODE,
2752                                           "otype:steal", (yyvsp[(2) - (5)].id),
2753                                           "ptype:steal", (yyvsp[(4) - (5)].id),
2754                                           "bonobo_object_class:steal", bonobo_object_class,
2755                                           "glade_xml", glade_xml,
2756                                           "interfaces:steal", interfaces,
2757                                           "chunk_size:steal", chunk_size,
2758                                           "abstract", abstract,
2759                                           NULL);
2760                         bonobo_object_class = NULL;
2761                         glade_xml = FALSE;
2762                         chunk_size = NULL;
2763                         interfaces = NULL;
2764                                                 }
2765     break;
2766
2767   case 26:
2768 /* Line 1792 of yacc.c  */
2769 #line 833 "parse.y"
2770     {
2771                         if(strcmp((yyvsp[(2) - (4)].id),"abstract") == 0) {
2772                                 abstract = TRUE;
2773                         } else {
2774                                 yyerror(_("parse error"));
2775                                 YYERROR;
2776                         }
2777                 }
2778     break;
2779
2780   case 27:
2781 /* Line 1792 of yacc.c  */
2782 #line 841 "parse.y"
2783     {
2784                         if(strcmp((yyvsp[(2) - (5)].id),"chunks") == 0) {
2785                                 g_free (chunk_size);
2786                                 chunk_size = g_strdup((yyvsp[(3) - (5)].id));
2787                         } else if(strcmp((yyvsp[(2) - (5)].id),"BonoboObject") == 0) {
2788                                 g_free (bonobo_object_class);
2789                                 bonobo_object_class = g_strdup((yyvsp[(3) - (5)].id));
2790                         } else {
2791                                 yyerror(_("parse error"));
2792                                 YYERROR;
2793                         }
2794                 }
2795     break;
2796
2797   case 28:
2798 /* Line 1792 of yacc.c  */
2799 #line 853 "parse.y"
2800     {
2801                         if (strcmp ((yyvsp[(2) - (5)].id), "interface") == 0) {
2802                                 interfaces = g_list_append (interfaces,
2803                                                             g_strdup ((yyvsp[(3) - (5)].id)));
2804                         } else {
2805                                 yyerror(_("parse error"));
2806                                 YYERROR;
2807                         }
2808                 }
2809     break;
2810
2811   case 29:
2812 /* Line 1792 of yacc.c  */
2813 #line 862 "parse.y"
2814     {
2815                         if(strcmp((yyvsp[(2) - (5)].id),"chunks") == 0) {
2816                                 g_free (chunk_size);
2817                                 if(atoi((yyvsp[(3) - (5)].id)) != 0)
2818                                         chunk_size = g_strdup((yyvsp[(3) - (5)].id));
2819                                 else
2820                                         chunk_size = NULL;
2821                         } else {
2822                                 yyerror(_("parse error"));
2823                                 YYERROR;
2824                         }
2825                 }
2826     break;
2827
2828   case 30:
2829 /* Line 1792 of yacc.c  */
2830 #line 874 "parse.y"
2831     {
2832                         if (strcmp ((yyvsp[(2) - (6)].id), "GladeXML") == 0) {
2833                                 glade_xml = TRUE;
2834                                 add_construct_glade((yyvsp[(3) - (6)].id), (yyvsp[(4) - (6)].id), NULL);
2835                         } else {
2836                                 yyerror(_("parse error"));
2837                                 YYERROR;
2838                         }
2839                 }
2840     break;
2841
2842   case 31:
2843 /* Line 1792 of yacc.c  */
2844 #line 883 "parse.y"
2845     {
2846                         if (strcmp ((yyvsp[(2) - (7)].id), "GladeXML") == 0) {
2847                                 glade_xml = TRUE;
2848                                 add_construct_glade((yyvsp[(3) - (7)].id), (yyvsp[(4) - (7)].id), (yyvsp[(5) - (7)].id));
2849                         } else {
2850                                 yyerror(_("parse error"));
2851                                 YYERROR;
2852                         }
2853                 }
2854     break;
2855
2856   case 32:
2857 /* Line 1792 of yacc.c  */
2858 #line 892 "parse.y"
2859     {
2860                         if (strcmp ((yyvsp[(2) - (6)].id), "GladeXML") == 0) {
2861                                 glade_xml = TRUE;
2862                                 add_construct_glade((yyvsp[(3) - (6)].id), (yyvsp[(4) - (6)].id), NULL);
2863                         } else {
2864                                 yyerror(_("parse error"));
2865                                 YYERROR;
2866                         }
2867                 }
2868     break;
2869
2870   case 33:
2871 /* Line 1792 of yacc.c  */
2872 #line 901 "parse.y"
2873     {
2874                         if (strcmp ((yyvsp[(2) - (7)].id), "GladeXML") == 0) {
2875                                 glade_xml = TRUE;
2876                                 add_construct_glade((yyvsp[(3) - (7)].id), (yyvsp[(4) - (7)].id), (yyvsp[(5) - (7)].id));
2877                         } else {
2878                                 yyerror(_("parse error"));
2879                                 YYERROR;
2880                         }
2881                 }
2882     break;
2883
2884   case 34:
2885 /* Line 1792 of yacc.c  */
2886 #line 912 "parse.y"
2887     { ; }
2888     break;
2889
2890   case 35:
2891 /* Line 1792 of yacc.c  */
2892 #line 913 "parse.y"
2893     { ; }
2894     break;
2895
2896   case 36:
2897 /* Line 1792 of yacc.c  */
2898 #line 916 "parse.y"
2899     { ; }
2900     break;
2901
2902   case 37:
2903 /* Line 1792 of yacc.c  */
2904 #line 917 "parse.y"
2905     {
2906                         if (strcmp ((yyvsp[(1) - (2)].id), "BonoboObject") != 0) {
2907                                 g_free ((yyvsp[(1) - (2)].id));
2908                                 yyerror (_("parse error"));
2909                                 YYERROR;
2910                         }
2911                         g_free ((yyvsp[(1) - (2)].id));
2912                         last_added_method->bonobo_object_func = TRUE;
2913                                                 }
2914     break;
2915
2916   case 38:
2917 /* Line 1792 of yacc.c  */
2918 #line 926 "parse.y"
2919     {
2920                         if (strcmp ((yyvsp[(1) - (3)].id), "interface") != 0) {
2921                                 g_free ((yyvsp[(1) - (3)].id));
2922                                 g_free ((yyvsp[(2) - (3)].id));
2923                                 yyerror (_("parse error"));
2924                                 YYERROR;
2925                         }
2926                         g_free ((yyvsp[(1) - (3)].id));
2927                         node_set ((Node *)last_added_method,
2928                                   "interface:steal", (yyvsp[(2) - (3)].id),
2929                                   NULL);
2930                                                 }
2931     break;
2932
2933   case 39:
2934 /* Line 1792 of yacc.c  */
2935 #line 938 "parse.y"
2936     { ; }
2937     break;
2938
2939   case 40:
2940 /* Line 1792 of yacc.c  */
2941 #line 939 "parse.y"
2942     { ; }
2943     break;
2944
2945   case 41:
2946 /* Line 1792 of yacc.c  */
2947 #line 940 "parse.y"
2948     { ; }
2949     break;
2950
2951   case 42:
2952 /* Line 1792 of yacc.c  */
2953 #line 941 "parse.y"
2954     { ; }
2955     break;
2956
2957   case 43:
2958 /* Line 1792 of yacc.c  */
2959 #line 944 "parse.y"
2960     { the_scope = PUBLIC_SCOPE; }
2961     break;
2962
2963   case 44:
2964 /* Line 1792 of yacc.c  */
2965 #line 945 "parse.y"
2966     { the_scope = PRIVATE_SCOPE; }
2967     break;
2968
2969   case 45:
2970 /* Line 1792 of yacc.c  */
2971 #line 946 "parse.y"
2972     { the_scope = PROTECTED_SCOPE; }
2973     break;
2974
2975   case 46:
2976 /* Line 1792 of yacc.c  */
2977 #line 947 "parse.y"
2978     { the_scope = CLASS_SCOPE; }
2979     break;
2980
2981   case 47:
2982 /* Line 1792 of yacc.c  */
2983 #line 950 "parse.y"
2984     {
2985                         if (strcmp ((yyvsp[(1) - (2)].id), "destroywith") == 0) {
2986                                 g_free ((yyvsp[(1) - (2)].id));
2987                                 destructor_unref = FALSE;
2988                                 destructor = (yyvsp[(2) - (2)].id);
2989                                 destructor_line = line_no;
2990                                 destructor_simple = TRUE;
2991                         } else if (strcmp ((yyvsp[(1) - (2)].id), "unrefwith") == 0) {
2992                                 g_free ((yyvsp[(1) - (2)].id));
2993                                 destructor_unref = TRUE;
2994                                 destructor = (yyvsp[(2) - (2)].id);
2995                                 destructor_line = line_no;
2996                                 destructor_simple = TRUE;
2997                         } else {
2998                                 g_free ((yyvsp[(1) - (2)].id));
2999                                 g_free ((yyvsp[(2) - (2)].id));
3000                                 yyerror (_("parse error"));
3001                                 YYERROR;
3002                         }
3003                                 }
3004     break;
3005
3006   case 48:
3007 /* Line 1792 of yacc.c  */
3008 #line 970 "parse.y"
3009     {
3010                         if (strcmp ((yyvsp[(1) - (3)].id), "destroy") == 0) {
3011                                 g_free((yyvsp[(1) - (3)].id));
3012                                 destructor_unref = FALSE;
3013                                 destructor = ((yyvsp[(3) - (3)].cbuf))->str;
3014                                 g_string_free((yyvsp[(3) - (3)].cbuf), FALSE);
3015                                 destructor_line = ccode_line;
3016                                 destructor_simple = FALSE;
3017                         } else if (strcmp ((yyvsp[(1) - (3)].id), "unref") == 0) {
3018                                 g_free ((yyvsp[(1) - (3)].id));
3019                                 destructor_unref = TRUE;
3020                                 destructor = ((yyvsp[(3) - (3)].cbuf))->str;
3021                                 g_string_free ((yyvsp[(3) - (3)].cbuf), FALSE);
3022                                 destructor_line = ccode_line;
3023                                 destructor_simple = FALSE;
3024                         } else {
3025                                 g_free ((yyvsp[(1) - (3)].id));
3026                                 g_string_free ((yyvsp[(3) - (3)].cbuf), TRUE);
3027                                 yyerror (_("parse error"));
3028                                 YYERROR;
3029                         }
3030                                         }
3031     break;
3032
3033   case 49:
3034 /* Line 1792 of yacc.c  */
3035 #line 994 "parse.y"
3036     {
3037                         initializer = (yyvsp[(2) - (2)].id);
3038                         initializer_line = ccode_line;
3039                                 }
3040     break;
3041
3042   case 50:
3043 /* Line 1792 of yacc.c  */
3044 #line 998 "parse.y"
3045     {
3046                         initializer = ((yyvsp[(3) - (3)].cbuf))->str;
3047                         initializer_line = ccode_line;
3048                         g_string_free((yyvsp[(3) - (3)].cbuf), FALSE);
3049                                 }
3050     break;
3051
3052   case 51:
3053 /* Line 1792 of yacc.c  */
3054 #line 1006 "parse.y"
3055     { ; }
3056     break;
3057
3058   case 52:
3059 /* Line 1792 of yacc.c  */
3060 #line 1007 "parse.y"
3061     { ; }
3062     break;
3063
3064   case 53:
3065 /* Line 1792 of yacc.c  */
3066 #line 1008 "parse.y"
3067     { destructor = NULL; }
3068     break;
3069
3070   case 54:
3071 /* Line 1792 of yacc.c  */
3072 #line 1009 "parse.y"
3073     { initializer = NULL; }
3074     break;
3075
3076   case 55:
3077 /* Line 1792 of yacc.c  */
3078 #line 1010 "parse.y"
3079     {
3080                         if (strcmp ((yyvsp[(1) - (1)].id), "GladeXML") == 0) {
3081                                 glade_widget = TRUE;
3082                         } else {
3083                                 yyerror(_("parse error"));
3084                                 YYERROR;
3085                         }
3086                                         }
3087     break;
3088
3089   case 56:
3090 /* Line 1792 of yacc.c  */
3091 #line 1018 "parse.y"
3092     {
3093                         destructor = NULL;
3094                         initializer = NULL;
3095                                         }
3096     break;
3097
3098   case 57:
3099 /* Line 1792 of yacc.c  */
3100 #line 1024 "parse.y"
3101     {
3102                         push_variable((yyvsp[(3) - (5)].id), the_scope,(yyvsp[(1) - (5)].line), NULL);
3103                                                 }
3104     break;
3105
3106   case 58:
3107 /* Line 1792 of yacc.c  */
3108 #line 1027 "parse.y"
3109     {
3110                         push_variable((yyvsp[(3) - (6)].id), the_scope, (yyvsp[(1) - (6)].line), (yyvsp[(4) - (6)].id));
3111                                                 }
3112     break;
3113
3114   case 59:
3115 /* Line 1792 of yacc.c  */
3116 #line 1032 "parse.y"
3117     {
3118                         Node *node = NULL;
3119                         if(strcmp((yyvsp[(6) - (12)].id),"get")==0 &&
3120                            strcmp((yyvsp[(9) - (12)].id),"set")==0) {
3121                                 Type *type = pop_type();
3122                                 g_free ((yyvsp[(6) - (12)].id));
3123                                 g_free ((yyvsp[(9) - (12)].id));
3124                                 node = node_new (ARGUMENT_NODE,
3125                                                  "gtktype:steal", (yyvsp[(3) - (12)].id),
3126                                                  "atype:steal", type,
3127                                                  "flags:steal", (yyvsp[(2) - (12)].list),
3128                                                  "name:steal", (yyvsp[(4) - (12)].id),
3129                                                  "get:steal", ((yyvsp[(8) - (12)].cbuf))->str,
3130                                                  "get_line", (yyvsp[(7) - (12)].line),
3131                                                  "set:steal", ((yyvsp[(11) - (12)].cbuf))->str,
3132                                                  "set_line", (yyvsp[(10) - (12)].line),
3133                                                  "line_no", (yyvsp[(1) - (12)].line),
3134                                                  NULL);
3135
3136                                 class_nodes = g_list_append(class_nodes,node);
3137
3138                                 g_string_free ((yyvsp[(8) - (12)].cbuf), FALSE);
3139                                 g_string_free ((yyvsp[(11) - (12)].cbuf), FALSE);
3140
3141                         } else if(strcmp((yyvsp[(6) - (12)].id),"set")==0 &&
3142                                 strcmp((yyvsp[(9) - (12)].id),"get")==0) {
3143                                 Type *type = pop_type();
3144                                 g_free ((yyvsp[(6) - (12)].id));
3145                                 g_free ((yyvsp[(9) - (12)].id));
3146                                 node = node_new (ARGUMENT_NODE,
3147                                                  "gtktype:steal", (yyvsp[(3) - (12)].id),
3148                                                  "atype:steal", type,
3149                                                  "flags:steal", (yyvsp[(2) - (12)].list),
3150                                                  "name:steal", (yyvsp[(4) - (12)].id),
3151                                                  "get:steal", ((yyvsp[(11) - (12)].cbuf))->str,
3152                                                  "get_line", (yyvsp[(10) - (12)].line),
3153                                                  "set:steal", ((yyvsp[(8) - (12)].cbuf))->str,
3154                                                  "set_line", (yyvsp[(7) - (12)].line),
3155                                                  "line_no", (yyvsp[(1) - (12)].line),
3156                                                  NULL);
3157                                 g_string_free ((yyvsp[(11) - (12)].cbuf), FALSE);
3158                                 g_string_free ((yyvsp[(8) - (12)].cbuf), FALSE);
3159                                 class_nodes = g_list_append(class_nodes,node);
3160                         } else {
3161                                 g_free ((yyvsp[(3) - (12)].id));
3162                                 g_free ((yyvsp[(4) - (12)].id));
3163                                 g_free ((yyvsp[(6) - (12)].id));
3164                                 g_free ((yyvsp[(9) - (12)].id));
3165                                 g_list_foreach ((yyvsp[(2) - (12)].list), (GFunc)g_free, NULL);
3166                                 g_list_free ((yyvsp[(2) - (12)].list));
3167                                 g_string_free ((yyvsp[(11) - (12)].cbuf), TRUE);
3168                                 g_string_free ((yyvsp[(8) - (12)].cbuf), TRUE);
3169                                 yyerror (_("parse error"));
3170                                 YYERROR;
3171                         }
3172
3173                         if ((yyvsp[(5) - (12)].id) != NULL) {
3174                                 Argument *arg = (Argument *)node;
3175                                 export_accessors (arg->name,
3176                                                   arg->get != NULL, arg->get_line,
3177                                                   arg->set != NULL, arg->set_line,
3178                                                   arg->atype,
3179                                                   arg->gtktype,
3180                                                   arg->line_no);
3181                                 g_free ((yyvsp[(5) - (12)].id));
3182                         }
3183
3184                                                 }
3185     break;
3186
3187   case 60:
3188 /* Line 1792 of yacc.c  */
3189 #line 1100 "parse.y"
3190     {
3191                         Node *node = NULL;
3192                         if(strcmp((yyvsp[(6) - (9)].id), "get") == 0) {
3193                                 Type *type = pop_type();
3194                                 g_free ((yyvsp[(6) - (9)].id));
3195                                 node = node_new (ARGUMENT_NODE,
3196                                                  "gtktype:steal", (yyvsp[(3) - (9)].id),
3197                                                  "atype:steal", type,
3198                                                  "flags:steal", (yyvsp[(2) - (9)].list),
3199                                                  "name:steal", (yyvsp[(4) - (9)].id),
3200                                                  "get:steal", ((yyvsp[(8) - (9)].cbuf))->str,
3201                                                  "get_line", (yyvsp[(7) - (9)].line),
3202                                                  "line_no", (yyvsp[(1) - (9)].line),
3203                                                  NULL);
3204
3205                                 g_string_free ((yyvsp[(8) - (9)].cbuf), FALSE);
3206                                 class_nodes = g_list_append(class_nodes, node);
3207                         } else if(strcmp((yyvsp[(6) - (9)].id), "set") == 0) {
3208                                 Type *type = pop_type();
3209                                 g_free ((yyvsp[(6) - (9)].id));
3210                                 node = node_new (ARGUMENT_NODE,
3211                                                  "gtktype:steal", (yyvsp[(3) - (9)].id),
3212                                                  "atype:steal", type,
3213                                                  "flags:steal", (yyvsp[(2) - (9)].list),
3214                                                  "name:steal", (yyvsp[(4) - (9)].id),
3215                                                  "set:steal", ((yyvsp[(8) - (9)].cbuf))->str,
3216                                                  "set_line", (yyvsp[(7) - (9)].line),
3217                                                  "line_no", (yyvsp[(1) - (9)].line),
3218                                                  NULL);
3219
3220                                 g_string_free ((yyvsp[(8) - (9)].cbuf), FALSE);
3221                                 class_nodes = g_list_append (class_nodes, node);
3222                         } else {
3223                                 g_free ((yyvsp[(6) - (9)].id));
3224                                 g_free ((yyvsp[(3) - (9)].id));
3225                                 g_free ((yyvsp[(4) - (9)].id));
3226                                 g_list_foreach ((yyvsp[(2) - (9)].list), (GFunc)g_free, NULL);
3227                                 g_list_free ((yyvsp[(2) - (9)].list));
3228                                 g_string_free ((yyvsp[(8) - (9)].cbuf), TRUE);
3229                                 yyerror(_("parse error"));
3230                                 YYERROR;
3231                         }
3232
3233                         if ((yyvsp[(5) - (9)].id) != NULL) {
3234                                 Argument *arg = (Argument *)node;
3235                                 export_accessors (arg->name,
3236                                                   arg->get != NULL, arg->get_line,
3237                                                   arg->set != NULL, arg->set_line,
3238                                                   arg->atype,
3239                                                   arg->gtktype,
3240                                                   arg->line_no);
3241                                 g_free ((yyvsp[(5) - (9)].id));
3242                         }
3243                                                 }
3244     break;
3245
3246   case 61:
3247 /* Line 1792 of yacc.c  */
3248 #line 1154 "parse.y"
3249     {
3250                         Node *node;
3251                         char *get, *set = NULL;
3252                         Variable *var;
3253                         Type *type;
3254                         const char *root;
3255
3256                         if(strcmp((yyvsp[(6) - (6)].id), "link")!=0 &&
3257                            strcmp((yyvsp[(6) - (6)].id), "stringlink")!=0 &&
3258                            strcmp((yyvsp[(6) - (6)].id), "objectlink")!=0) {
3259                                 g_free((yyvsp[(6) - (6)].id));
3260                                 g_free((yyvsp[(3) - (6)].id));
3261                                 g_free((yyvsp[(4) - (6)].id));
3262                                 g_list_foreach((yyvsp[(2) - (6)].list),(GFunc)g_free,NULL);
3263                                 g_list_free((yyvsp[(2) - (6)].list));
3264                                 yyerror(_("parse error"));
3265                                 YYERROR;
3266                         }
3267
3268                         type = pop_type();
3269
3270                         var = find_var_or_die((yyvsp[(4) - (6)].id), (yyvsp[(1) - (6)].line));
3271                         if(var->scope == PRIVATE_SCOPE) {
3272                                 root = "self->_priv";
3273                         } else if(var->scope == CLASS_SCOPE) {
3274                                 root = "SELF_GET_CLASS(self)";
3275                                 if(no_self_alias)
3276                                         error_print(GOB_ERROR, (yyvsp[(1) - (6)].line),
3277                                                     _("Self aliases needed when autolinking to a classwide member"));
3278                         } else {
3279                                 root = "self";
3280                         }
3281
3282                         if(strcmp((yyvsp[(6) - (6)].id), "link")==0) {
3283                                 set = g_strdup_printf("%s->%s = ARG;",
3284                                                       root, (yyvsp[(4) - (6)].id));
3285                         } else if(strcmp((yyvsp[(6) - (6)].id), "stringlink")==0) {
3286                                 set = g_strdup_printf("g_free (%s->%s); "
3287                                                       "%s->%s = g_strdup (ARG);",
3288                                                       root, (yyvsp[(4) - (6)].id),
3289                                                       root, (yyvsp[(4) - (6)].id));
3290                         } else if(strcmp((yyvsp[(6) - (6)].id), "objectlink")==0) {
3291                                 set = g_strdup_printf(
3292                                   "if (ARG != NULL) "
3293                                    "g_object_ref (G_OBJECT (ARG)); "
3294                                   "if (%s->%s != NULL) "
3295                                    "g_object_unref (G_OBJECT (%s->%s)); "
3296                                   "%s->%s = ARG;",
3297                                   root, (yyvsp[(4) - (6)].id),
3298                                   root, (yyvsp[(4) - (6)].id),
3299                                   root, (yyvsp[(4) - (6)].id));
3300                         } else {
3301                                 g_assert_not_reached();
3302                         }
3303
3304                         get = g_strdup_printf("ARG = %s->%s;", root, (yyvsp[(4) - (6)].id));
3305
3306                         g_free ((yyvsp[(6) - (6)].id));
3307
3308                         if (type == NULL)
3309                                 type = (Type *)node_copy ((Node *)var->vtype);
3310
3311                         node = node_new (ARGUMENT_NODE,
3312                                          "gtktype:steal", (yyvsp[(3) - (6)].id),
3313                                          "atype:steal", type,
3314                                          "flags:steal", (yyvsp[(2) - (6)].list),
3315                                          "name:steal", (yyvsp[(4) - (6)].id),
3316                                          "get:steal", get,
3317                                          "get_line", (yyvsp[(1) - (6)].line),
3318                                          "set:steal", set,
3319                                          "set_line", (yyvsp[(1) - (6)].line),
3320                                          "line_no", (yyvsp[(1) - (6)].line),
3321                                          NULL);
3322
3323                         if ((yyvsp[(5) - (6)].id) != NULL) {
3324                                 Argument *arg = (Argument *)node;
3325                                 export_accessors (arg->name,
3326                                                   arg->get != NULL, arg->get_line,
3327                                                   arg->set != NULL, arg->set_line,
3328                                                   arg->atype,
3329                                                   arg->gtktype,
3330                                                   arg->line_no);
3331                                 g_free ((yyvsp[(5) - (6)].id));
3332                         }
3333
3334                         class_nodes = g_list_append (class_nodes, node);
3335                                                 }
3336     break;
3337
3338   case 62:
3339 /* Line 1792 of yacc.c  */
3340 #line 1243 "parse.y"
3341     {
3342                         if (strcmp ((yyvsp[(2) - (3)].id), "export")!=0) {
3343                                 g_free ((yyvsp[(2) - (3)].id));
3344                                 yyerror (_("parse error"));
3345                                 YYERROR;
3346                         }
3347                         (yyval.id) = (yyvsp[(2) - (3)].id);
3348                                                 }
3349     break;
3350
3351   case 63:
3352 /* Line 1792 of yacc.c  */
3353 #line 1251 "parse.y"
3354     {
3355                         (yyval.id) = NULL;
3356                                                 }
3357     break;
3358
3359   case 64:
3360 /* Line 1792 of yacc.c  */
3361 #line 1256 "parse.y"
3362     {
3363                         ensure_property ();
3364                         node_set ((Node *)property,
3365                                   "line_no", (yyvsp[(1) - (11)].line),
3366                                   "gtktype:steal", debool ((yyvsp[(2) - (11)].id)),
3367                                   "name:steal", (yyvsp[(3) - (11)].id),
3368                                   NULL);
3369                         if (strcmp ((yyvsp[(5) - (11)].id), "get") == 0 &&
3370                             strcmp ((yyvsp[(8) - (11)].id), "set") == 0) {
3371                                 node_set ((Node *)property,
3372                                           "get:steal", ((yyvsp[(7) - (11)].cbuf))->str,
3373                                           "get_line", (yyvsp[(6) - (11)].line),
3374                                           "set:steal", ((yyvsp[(10) - (11)].cbuf))->str,
3375                                           "set_line", (yyvsp[(9) - (11)].line),
3376                                           NULL);
3377                                 g_string_free ((yyvsp[(7) - (11)].cbuf), FALSE);
3378                                 g_string_free ((yyvsp[(10) - (11)].cbuf), FALSE);
3379                                 g_free ((yyvsp[(5) - (11)].id));
3380                                 g_free ((yyvsp[(8) - (11)].id));
3381                         } else if (strcmp ((yyvsp[(5) - (11)].id), "set") == 0 &&
3382                                    strcmp ((yyvsp[(8) - (11)].id), "get") == 0) {
3383                                 node_set ((Node *)property,
3384                                           "get:steal", ((yyvsp[(10) - (11)].cbuf))->str,
3385                                           "get_line", (yyvsp[(9) - (11)].line),
3386                                           "set:steal", ((yyvsp[(7) - (11)].cbuf))->str,
3387                                           "set_line", (yyvsp[(6) - (11)].line),
3388                                           NULL);
3389                                 g_string_free ((yyvsp[(7) - (11)].cbuf), FALSE);
3390                                 g_string_free ((yyvsp[(10) - (11)].cbuf), FALSE);
3391                                 g_free ((yyvsp[(5) - (11)].id));
3392                                 g_free ((yyvsp[(8) - (11)].id));
3393                         } else {
3394                                 g_string_free ((yyvsp[(7) - (11)].cbuf), TRUE);
3395                                 g_string_free ((yyvsp[(10) - (11)].cbuf), TRUE);
3396                                 g_free ((yyvsp[(5) - (11)].id));
3397                                 g_free ((yyvsp[(8) - (11)].id));
3398                                 node_free ((Node *)property);
3399                                 property = NULL;
3400                                 yyerror (_("parse error"));
3401                                 YYERROR;
3402                         }
3403                         property_link_and_export ((Node *)property);
3404                         if (property != NULL) {
3405                                 class_nodes = g_list_append (class_nodes,
3406                                                              property);
3407                                 property = NULL;
3408                         }
3409                 }
3410     break;
3411
3412   case 65:
3413 /* Line 1792 of yacc.c  */
3414 #line 1304 "parse.y"
3415     {
3416                         ensure_property ();
3417                         node_set ((Node *)property,
3418                                   "line_no", (yyvsp[(1) - (8)].line),
3419                                   "gtktype:steal", debool ((yyvsp[(2) - (8)].id)),
3420                                   "name:steal", (yyvsp[(3) - (8)].id),
3421                                   NULL);
3422                         if (strcmp ((yyvsp[(5) - (8)].id), "get") == 0) {
3423                                 node_set ((Node *)property,
3424                                           "get:steal", ((yyvsp[(7) - (8)].cbuf))->str,
3425                                           "get_line", (yyvsp[(6) - (8)].line),
3426                                           NULL);
3427                                 g_string_free ((yyvsp[(7) - (8)].cbuf), FALSE);
3428                                 g_free ((yyvsp[(5) - (8)].id));
3429                         } else if (strcmp ((yyvsp[(5) - (8)].id), "set") == 0) {
3430                                 node_set ((Node *)property,
3431                                           "set:steal", ((yyvsp[(7) - (8)].cbuf))->str,
3432                                           "set_line", (yyvsp[(6) - (8)].line),
3433                                           NULL);
3434                                 g_string_free ((yyvsp[(7) - (8)].cbuf), FALSE);
3435                                 g_free ((yyvsp[(5) - (8)].id));
3436                         } else {
3437                                 g_string_free ((yyvsp[(7) - (8)].cbuf), TRUE);
3438                                 g_free ((yyvsp[(5) - (8)].id));
3439                                 node_free ((Node *)property);
3440                                 property = NULL;
3441                                 yyerror (_("parse error"));
3442                                 YYERROR;
3443                         }
3444                         property_link_and_export ((Node *)property);
3445                         if (property != NULL) {
3446                                 class_nodes = g_list_append (class_nodes,
3447                                                              property);
3448                                 property = NULL;
3449                         }
3450                 }
3451     break;
3452
3453   case 66:
3454 /* Line 1792 of yacc.c  */
3455 #line 1340 "parse.y"
3456     {
3457                         ensure_property ();
3458                         node_set ((Node *)property,
3459                                   "line_no", (yyvsp[(1) - (5)].line),
3460                                   "gtktype:steal", debool ((yyvsp[(2) - (5)].id)),
3461                                   "name:steal", (yyvsp[(3) - (5)].id),
3462                                   NULL);
3463                         property_link_and_export ((Node *)property);
3464                         if (property != NULL) {
3465                                 class_nodes = g_list_append (class_nodes,
3466                                                              property);
3467                                 property = NULL;
3468                         }
3469                 }
3470     break;
3471
3472   case 67:
3473 /* Line 1792 of yacc.c  */
3474 #line 1356 "parse.y"
3475     { ; }
3476     break;
3477
3478   case 68:
3479 /* Line 1792 of yacc.c  */
3480 #line 1357 "parse.y"
3481     { ; }
3482     break;
3483
3484   case 69:
3485 /* Line 1792 of yacc.c  */
3486 #line 1360 "parse.y"
3487     { ; }
3488     break;
3489
3490   case 70:
3491 /* Line 1792 of yacc.c  */
3492 #line 1361 "parse.y"
3493     { ; }
3494     break;
3495
3496   case 71:
3497 /* Line 1792 of yacc.c  */
3498 #line 1364 "parse.y"
3499     { (yyval.id) = (yyvsp[(1) - (1)].id); }
3500     break;
3501
3502   case 72:
3503 /* Line 1792 of yacc.c  */
3504 #line 1365 "parse.y"
3505     {
3506                         if (strcmp ((yyvsp[(1) - (4)].id), "_") != 0) {
3507                                 g_free ((yyvsp[(1) - (4)].id));
3508                                 yyerror(_("parse error"));
3509                                 YYERROR;
3510                         }
3511                         g_free ((yyvsp[(1) - (4)].id));
3512                         (yyval.id) = g_strconcat ("_(", (yyvsp[(3) - (4)].id), ")", NULL);
3513                         g_free ((yyvsp[(3) - (4)].id));
3514                 }
3515     break;
3516
3517   case 73:
3518 /* Line 1792 of yacc.c  */
3519 #line 1377 "parse.y"
3520     { (yyval.id) = (yyvsp[(1) - (1)].id); }
3521     break;
3522
3523   case 74:
3524 /* Line 1792 of yacc.c  */
3525 #line 1378 "parse.y"
3526     { (yyval.id) = (yyvsp[(1) - (1)].id); }
3527     break;
3528
3529   case 75:
3530 /* Line 1792 of yacc.c  */
3531 #line 1381 "parse.y"
3532     {
3533                 ensure_property ();
3534                 node_set ((Node *)property,
3535                           "canonical_name:steal", gob_str_delete_quotes((yyvsp[(3) - (3)].id)),
3536                           NULL);
3537                   }
3538     break;
3539
3540   case 76:
3541 /* Line 1792 of yacc.c  */
3542 #line 1387 "parse.y"
3543     {
3544                 ensure_property ();
3545                 node_set ((Node *)property,
3546                           "nick:steal", (yyvsp[(3) - (3)].id),
3547                           NULL);
3548                   }
3549     break;
3550
3551   case 77:
3552 /* Line 1792 of yacc.c  */
3553 #line 1393 "parse.y"
3554     {
3555                 ensure_property ();
3556                 node_set ((Node *)property,
3557                           "blurb:steal", (yyvsp[(3) - (3)].id),
3558                           NULL);
3559                   }
3560     break;
3561
3562   case 78:
3563 /* Line 1792 of yacc.c  */
3564 #line 1399 "parse.y"
3565     {
3566                 ensure_property ();
3567                 node_set ((Node *)property,
3568                           "maximum:steal", (yyvsp[(3) - (3)].id),
3569                           NULL);
3570                   }
3571     break;
3572
3573   case 79:
3574 /* Line 1792 of yacc.c  */
3575 #line 1405 "parse.y"
3576     {
3577                 ensure_property ();
3578                 node_set ((Node *)property,
3579                           "minimum:steal", (yyvsp[(3) - (3)].id),
3580                           NULL);
3581                   }
3582     break;
3583
3584   case 80:
3585 /* Line 1792 of yacc.c  */
3586 #line 1411 "parse.y"
3587     {
3588                 ensure_property ();
3589                 node_set ((Node *)property,
3590                           "default_value:steal", (yyvsp[(3) - (3)].id),
3591                           NULL);
3592                   }
3593     break;
3594
3595   case 81:
3596 /* Line 1792 of yacc.c  */
3597 #line 1417 "parse.y"
3598     {
3599                 ensure_property ();
3600                 node_set ((Node *)property,
3601                           "flags:steal", (yyvsp[(3) - (3)].list),
3602                           NULL);
3603                   }
3604     break;
3605
3606   case 82:
3607 /* Line 1792 of yacc.c  */
3608 #line 1423 "parse.y"
3609     {
3610                 Type *type = pop_type ();
3611                 ensure_property ();
3612                 node_set ((Node *)property,
3613                           "ptype:steal", type,
3614                           NULL);
3615                   }
3616     break;
3617
3618   case 83:
3619 /* Line 1792 of yacc.c  */
3620 #line 1430 "parse.y"
3621     {
3622                 ensure_property ();
3623                 node_set ((Node *)property,
3624                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3625                           NULL);
3626                   }
3627     break;
3628
3629   case 84:
3630 /* Line 1792 of yacc.c  */
3631 #line 1436 "parse.y"
3632     {
3633                 ensure_property ();
3634                 node_set ((Node *)property,
3635                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3636                           NULL);
3637                   }
3638     break;
3639
3640   case 85:
3641 /* Line 1792 of yacc.c  */
3642 #line 1442 "parse.y"
3643     {
3644                 ensure_property ();
3645                 node_set ((Node *)property,
3646                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3647                           NULL);
3648                   }
3649     break;
3650
3651   case 86:
3652 /* Line 1792 of yacc.c  */
3653 #line 1448 "parse.y"
3654     {
3655                 ensure_property ();
3656                 node_set ((Node *)property,
3657                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3658                           NULL);
3659                   }
3660     break;
3661
3662   case 87:
3663 /* Line 1792 of yacc.c  */
3664 #line 1454 "parse.y"
3665     {
3666                 ensure_property ();
3667                 node_set ((Node *)property,
3668                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3669                           NULL);
3670                   }
3671     break;
3672
3673   case 88:
3674 /* Line 1792 of yacc.c  */
3675 #line 1460 "parse.y"
3676     {
3677                 ensure_property ();
3678                 node_set ((Node *)property,
3679                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3680                           NULL);
3681                   }
3682     break;
3683
3684   case 89:
3685 /* Line 1792 of yacc.c  */
3686 #line 1466 "parse.y"
3687     {
3688                 ensure_property ();
3689                 node_set ((Node *)property,
3690                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3691                           NULL);
3692                   }
3693     break;
3694
3695   case 90:
3696 /* Line 1792 of yacc.c  */
3697 #line 1472 "parse.y"
3698     {
3699                 ensure_property ();
3700                 node_set ((Node *)property,
3701                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3702                           NULL);
3703                   }
3704     break;
3705
3706   case 91:
3707 /* Line 1792 of yacc.c  */
3708 #line 1478 "parse.y"
3709     {
3710                 ensure_property ();
3711                 node_set ((Node *)property,
3712                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3713                           NULL);
3714                   }
3715     break;
3716
3717   case 92:
3718 /* Line 1792 of yacc.c  */
3719 #line 1484 "parse.y"
3720     {
3721                 ensure_property ();
3722                 node_set ((Node *)property,
3723                           "extra_gtktype:steal", (yyvsp[(3) - (3)].id),
3724                           NULL);
3725                   }
3726     break;
3727
3728   case 93:
3729 /* Line 1792 of yacc.c  */
3730 #line 1490 "parse.y"
3731     {
3732                 ensure_property ();
3733                 if (strcmp ((yyvsp[(1) - (1)].id), "override") == 0) {
3734                         g_free((yyvsp[(1) - (1)].id));
3735                         node_set ((Node *)property,
3736                                   "override", TRUE,
3737                                   NULL);
3738                 } else if (strcmp ((yyvsp[(1) - (1)].id), "link") == 0) {
3739                         g_free((yyvsp[(1) - (1)].id));
3740                         node_set ((Node *)property,
3741                                   "link", TRUE,
3742                                   NULL);
3743                 } else if (strcmp ((yyvsp[(1) - (1)].id), "export") == 0) {
3744                         g_free((yyvsp[(1) - (1)].id));
3745                         node_set ((Node *)property,
3746                                   "export", TRUE,
3747                                   NULL);
3748                 } else {
3749                         g_free((yyvsp[(1) - (1)].id));
3750                         yyerror(_("parse error"));
3751                         YYERROR;
3752                 }
3753                   }
3754     break;
3755
3756   case 94:
3757 /* Line 1792 of yacc.c  */
3758 #line 1515 "parse.y"
3759     {
3760                         if(strcmp((yyvsp[(3) - (5)].id),"type")!=0) {
3761                                 g_free((yyvsp[(1) - (5)].id));
3762                                 g_free((yyvsp[(3) - (5)].id));
3763                                 yyerror(_("parse error"));
3764                                 YYERROR;
3765                         }
3766                         (yyval.id) = debool ((yyvsp[(1) - (5)].id));
3767                                                 }
3768     break;
3769
3770   case 95:
3771 /* Line 1792 of yacc.c  */
3772 #line 1524 "parse.y"
3773     {
3774                         (yyval.id) = debool ((yyvsp[(1) - (1)].id));
3775                         typestack = g_list_prepend(typestack,NULL);
3776                                                 }
3777     break;
3778
3779   case 96:
3780 /* Line 1792 of yacc.c  */
3781 #line 1530 "parse.y"
3782     { (yyval.list) = (yyvsp[(2) - (3)].list); }
3783     break;
3784
3785   case 97:
3786 /* Line 1792 of yacc.c  */
3787 #line 1531 "parse.y"
3788     { (yyval.list) = NULL; }
3789     break;
3790
3791   case 98:
3792 /* Line 1792 of yacc.c  */
3793 #line 1534 "parse.y"
3794     {
3795                         (yyval.list) = g_list_append((yyvsp[(3) - (3)].list),(yyvsp[(1) - (3)].id));
3796                                                 }
3797     break;
3798
3799   case 99:
3800 /* Line 1792 of yacc.c  */
3801 #line 1537 "parse.y"
3802     {
3803                         (yyval.list) = g_list_append(NULL,(yyvsp[(1) - (1)].id));
3804                                                 }
3805     break;
3806
3807   case 100:
3808 /* Line 1792 of yacc.c  */
3809 #line 1543 "parse.y"
3810     {
3811                         Node *node = node_new (TYPE_NODE,
3812                                                "name:steal", (yyvsp[(1) - (2)].id),
3813                                                "pointer:steal", (yyvsp[(2) - (2)].id),
3814                                                NULL);
3815                         typestack = g_list_prepend(typestack,node);
3816                                                         }
3817     break;
3818
3819   case 101:
3820 /* Line 1792 of yacc.c  */
3821 #line 1550 "parse.y"
3822     {
3823                         Node *node = node_new (TYPE_NODE,
3824                                                "name:steal", (yyvsp[(1) - (1)].id),
3825                                                NULL);
3826                         typestack = g_list_prepend(typestack,node);
3827                                                         }
3828     break;
3829
3830   case 102:
3831 /* Line 1792 of yacc.c  */
3832 #line 1559 "parse.y"
3833     {
3834                         (yyval.id) = (yyvsp[(1) - (1)].id);
3835                                                         }
3836     break;
3837
3838   case 103:
3839 /* Line 1792 of yacc.c  */
3840 #line 1562 "parse.y"
3841     {
3842                         (yyval.id) = (yyvsp[(1) - (1)].id);
3843                                                         }
3844     break;
3845
3846   case 104:
3847 /* Line 1792 of yacc.c  */
3848 #line 1565 "parse.y"
3849     {
3850                         (yyval.id) = g_strconcat("const ", (yyvsp[(2) - (2)].id), NULL);
3851                         g_free((yyvsp[(2) - (2)].id));
3852                                                         }
3853     break;
3854
3855   case 105:
3856 /* Line 1792 of yacc.c  */
3857 #line 1569 "parse.y"
3858     {
3859                         (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " const", NULL);
3860                         g_free((yyvsp[(1) - (2)].id));
3861                                                         }
3862     break;
3863
3864   case 106:
3865 /* Line 1792 of yacc.c  */
3866 #line 1573 "parse.y"
3867     {
3868                         (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " ", (yyvsp[(2) - (2)].id), NULL);
3869                         g_free((yyvsp[(2) - (2)].id));
3870                                                         }
3871     break;
3872
3873   case 107:
3874 /* Line 1792 of yacc.c  */
3875 #line 1577 "parse.y"
3876     {
3877                         (yyval.id) = g_strconcat("const ", (yyvsp[(2) - (3)].id), " ",
3878                                              (yyvsp[(3) - (3)].id), NULL);
3879                         g_free((yyvsp[(3) - (3)].id));
3880                                                         }
3881     break;
3882
3883   case 108:
3884 /* Line 1792 of yacc.c  */
3885 #line 1582 "parse.y"
3886     {
3887                         (yyval.id) = g_strconcat((yyvsp[(1) - (3)].id), " ",
3888                                              (yyvsp[(2) - (3)].id), " const", NULL);
3889                         g_free((yyvsp[(2) - (3)].id));
3890                                                         }
3891     break;
3892
3893   case 109:
3894 /* Line 1792 of yacc.c  */
3895 #line 1590 "parse.y"
3896     {
3897                         (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " ", (yyvsp[(2) - (2)].id), NULL);
3898                         g_free((yyvsp[(2) - (2)].id));
3899                                                         }
3900     break;
3901
3902   case 110:
3903 /* Line 1792 of yacc.c  */
3904 #line 1594 "parse.y"
3905     {
3906                         (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " ", (yyvsp[(2) - (2)].id), NULL);
3907                         g_free((yyvsp[(1) - (2)].id));
3908                         g_free((yyvsp[(2) - (2)].id));
3909                                                         }
3910     break;
3911
3912   case 111:
3913 /* Line 1792 of yacc.c  */
3914 #line 1599 "parse.y"
3915     {
3916                         (yyval.id) = g_strconcat("const ", (yyvsp[(2) - (2)].id), NULL);
3917                         g_free((yyvsp[(2) - (2)].id));
3918                                                         }
3919     break;
3920
3921   case 112:
3922 /* Line 1792 of yacc.c  */
3923 #line 1603 "parse.y"
3924     {
3925                         (yyval.id) = (yyvsp[(1) - (1)].id);
3926                                                         }
3927     break;
3928
3929   case 113:
3930 /* Line 1792 of yacc.c  */
3931 #line 1606 "parse.y"
3932     {
3933                         (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " const", NULL);
3934                         g_free((yyvsp[(1) - (2)].id));
3935                                                         }
3936     break;
3937
3938   case 114:
3939 /* Line 1792 of yacc.c  */
3940 #line 1610 "parse.y"
3941     {
3942                         (yyval.id) = g_strdup((yyvsp[(1) - (1)].id));
3943                                                         }
3944     break;
3945
3946   case 115:
3947 /* Line 1792 of yacc.c  */
3948 #line 1613 "parse.y"
3949     {
3950                         (yyval.id) = g_strconcat((yyvsp[(1) - (2)].id), " const", NULL);
3951                                                         }
3952     break;
3953
3954   case 116:
3955 /* Line 1792 of yacc.c  */
3956 #line 1618 "parse.y"
3957     { (yyval.id) = "void"; }
3958     break;
3959
3960   case 117:
3961 /* Line 1792 of yacc.c  */
3962 #line 1619 "parse.y"
3963     { (yyval.id) = "char"; }
3964     break;
3965
3966   case 118:
3967 /* Line 1792 of yacc.c  */
3968 #line 1620 "parse.y"
3969     { (yyval.id) = "short"; }
3970     break;
3971
3972   case 119:
3973 /* Line 1792 of yacc.c  */
3974 #line 1621 "parse.y"
3975     { (yyval.id) = "int"; }
3976     break;
3977
3978   case 120:
3979 /* Line 1792 of yacc.c  */
3980 #line 1622 "parse.y"
3981     { (yyval.id) = "long"; }
3982     break;
3983
3984   case 121:
3985 /* Line 1792 of yacc.c  */
3986 #line 1623 "parse.y"
3987     { (yyval.id) = "float"; }
3988     break;
3989
3990   case 122:
3991 /* Line 1792 of yacc.c  */
3992 #line 1624 "parse.y"
3993     { (yyval.id) = "double"; }
3994     break;
3995
3996   case 123:
3997 /* Line 1792 of yacc.c  */
3998 #line 1625 "parse.y"
3999     { (yyval.id) = "signed"; }
4000     break;
4001
4002   case 124:
4003 /* Line 1792 of yacc.c  */
4004 #line 1626 "parse.y"
4005     { (yyval.id) = "unsigned"; }
4006     break;
4007
4008   case 125:
4009 /* Line 1792 of yacc.c  */
4010 #line 1629 "parse.y"
4011     { (yyval.id) = "struct"; }
4012     break;
4013
4014   case 126:
4015 /* Line 1792 of yacc.c  */
4016 #line 1630 "parse.y"
4017     { (yyval.id) = "union"; }
4018     break;
4019
4020   case 127:
4021 /* Line 1792 of yacc.c  */
4022 #line 1631 "parse.y"
4023     { (yyval.id) = "enum"; }
4024     break;
4025
4026   case 128:
4027 /* Line 1792 of yacc.c  */
4028 #line 1634 "parse.y"
4029     { (yyval.id) = g_strdup("*"); }
4030     break;
4031
4032   case 129:
4033 /* Line 1792 of yacc.c  */
4034 #line 1635 "parse.y"
4035     { (yyval.id) = g_strdup("* const"); }
4036     break;
4037
4038   case 130:
4039 /* Line 1792 of yacc.c  */
4040 #line 1636 "parse.y"
4041     {
4042                                 (yyval.id) = g_strconcat("*", (yyvsp[(2) - (2)].id), NULL);
4043                                 g_free((yyvsp[(2) - (2)].id));
4044                                         }
4045     break;
4046
4047   case 131:
4048 /* Line 1792 of yacc.c  */
4049 #line 1640 "parse.y"
4050     {
4051                                 (yyval.id) = g_strconcat("* const", (yyvsp[(3) - (3)].id), NULL);
4052                                 g_free((yyvsp[(3) - (3)].id));
4053                                         }
4054     break;
4055
4056   case 132:
4057 /* Line 1792 of yacc.c  */
4058 #line 1647 "parse.y"
4059     {
4060                         if(strcmp((yyvsp[(1) - (2)].id), "first")==0)
4061                                 (yyval.sigtype) = SIGNAL_FIRST_METHOD;
4062                         else if(strcmp((yyvsp[(1) - (2)].id), "last")==0)
4063                                 (yyval.sigtype) = SIGNAL_LAST_METHOD;
4064                         else {
4065                                 yyerror(_("signal must be 'first' or 'last'"));
4066                                 g_free((yyvsp[(1) - (2)].id));
4067                                 YYERROR;
4068                         }
4069                         g_free((yyvsp[(1) - (2)].id));
4070                                         }
4071     break;
4072
4073   case 133:
4074 /* Line 1792 of yacc.c  */
4075 #line 1659 "parse.y"
4076     {
4077                         (yyval.sigtype) = SIGNAL_LAST_METHOD;
4078                                         }
4079     break;
4080
4081   case 134:
4082 /* Line 1792 of yacc.c  */
4083 #line 1665 "parse.y"
4084     {
4085                         if(strcmp((yyvsp[(2) - (3)].id),"first")==0)
4086                                 (yyval.sigtype) = SIGNAL_FIRST_METHOD;
4087                         else if(strcmp((yyvsp[(2) - (3)].id),"last")==0)
4088                                 (yyval.sigtype) = SIGNAL_LAST_METHOD;
4089                         else {
4090                                 yyerror(_("signal must be 'first' or 'last'"));
4091                                 g_free((yyvsp[(2) - (3)].id));
4092                                 YYERROR;
4093                         }
4094                         g_free((yyvsp[(2) - (3)].id));
4095                                         }
4096     break;
4097
4098   case 135:
4099 /* Line 1792 of yacc.c  */
4100 #line 1677 "parse.y"
4101     {
4102                         if(strcmp((yyvsp[(1) - (3)].id),"first")==0)
4103                                 (yyval.sigtype) = SIGNAL_FIRST_METHOD;
4104                         else if(strcmp((yyvsp[(1) - (3)].id),"last")==0)
4105                                 (yyval.sigtype) = SIGNAL_LAST_METHOD;
4106                         else {
4107                                 yyerror(_("signal must be 'first' or 'last'"));
4108                                 g_free((yyvsp[(1) - (3)].id));
4109                                 YYERROR;
4110                         }
4111                         g_free((yyvsp[(1) - (3)].id));
4112                                         }
4113     break;
4114
4115   case 136:
4116 /* Line 1792 of yacc.c  */
4117 #line 1689 "parse.y"
4118     {
4119                         (yyval.sigtype) = SIGNAL_LAST_METHOD;
4120                                         }
4121     break;
4122
4123   case 137:
4124 /* Line 1792 of yacc.c  */
4125 #line 1692 "parse.y"
4126     {
4127                         /* the_scope was default thus public */
4128                         the_scope = PUBLIC_SCOPE;
4129                                         }
4130     break;
4131
4132   case 138:
4133 /* Line 1792 of yacc.c  */
4134 #line 1698 "parse.y"
4135     {
4136                         gtktypes = g_list_prepend(gtktypes, debool ((yyvsp[(1) - (4)].id)));
4137                                                 }
4138     break;
4139
4140   case 139:
4141 /* Line 1792 of yacc.c  */
4142 #line 1701 "parse.y"
4143     {
4144                         gtktypes = g_list_prepend(gtktypes, debool ((yyvsp[(1) - (5)].id)));
4145                         signal_name=(yyvsp[(2) - (5)].id);
4146                                                 }
4147     break;
4148
4149   case 140:
4150 /* Line 1792 of yacc.c  */
4151 #line 1707 "parse.y"
4152     {
4153                         gtktypes = g_list_append(gtktypes, debool ((yyvsp[(3) - (3)].id)));
4154                                                 }
4155     break;
4156
4157   case 141:
4158 /* Line 1792 of yacc.c  */
4159 #line 1710 "parse.y"
4160     {
4161                         gtktypes = g_list_append(gtktypes, debool ((yyvsp[(1) - (1)].id)));
4162                                                 }
4163     break;
4164
4165   case 142:
4166 /* Line 1792 of yacc.c  */
4167 #line 1715 "parse.y"
4168     { (yyval.cbuf) = (yyvsp[(2) - (2)].cbuf); }
4169     break;
4170
4171   case 143:
4172 /* Line 1792 of yacc.c  */
4173 #line 1716 "parse.y"
4174     { (yyval.cbuf) = NULL; }
4175     break;
4176
4177   case 144:
4178 /* Line 1792 of yacc.c  */
4179 #line 1720 "parse.y"
4180     {
4181                         if(!has_self) {
4182                                 yyerror(_("signal without 'self' as "
4183                                           "first parameter"));
4184                                 free_all_global_state();
4185                                 YYERROR;
4186                         }
4187                         if(the_scope == CLASS_SCOPE) {
4188                                 yyerror(_("a method cannot be of class scope"));
4189                                 free_all_global_state();
4190                                 YYERROR;
4191                         }
4192                         if (funcattrs != NULL) {
4193                                 char *error = g_strdup_printf
4194                                         (_("function attribute macros ('%s' in this case) may not be used with signal methods"),
4195                                          funcattrs);
4196                                 yyerror (error);
4197                                 YYERROR;
4198                         }
4199                         push_function(the_scope, (yyvsp[(3) - (10)].sigtype),NULL,
4200                                       (yyvsp[(5) - (10)].id), (yyvsp[(10) - (10)].cbuf),(yyvsp[(1) - (10)].line),
4201                                       ccode_line, vararg, (yyvsp[(2) - (10)].list));
4202                                                                         }
4203     break;
4204
4205   case 145:
4206 /* Line 1792 of yacc.c  */
4207 #line 1743 "parse.y"
4208     {
4209                         if(!has_self) {
4210                                 yyerror(_("signal without 'self' as "
4211                                           "first parameter"));
4212                                 free_all_global_state();
4213                                 YYERROR;
4214                         }
4215                         if(the_scope == CLASS_SCOPE) {
4216                                 yyerror(_("a method cannot be of class scope"));
4217                                 free_all_global_state();
4218                                 YYERROR;
4219                         }
4220                         if (funcattrs != NULL) {
4221                                 char *error = g_strdup_printf
4222                                         (_("function attribute macros ('%s' in this case) may not be used with signal methods"),
4223                                          funcattrs);
4224                                 yyerror (error);
4225                                 YYERROR;
4226                         }
4227                         push_function(the_scope, (yyvsp[(4) - (11)].sigtype), NULL,
4228                                       (yyvsp[(6) - (11)].id), (yyvsp[(11) - (11)].cbuf), (yyvsp[(2) - (11)].line),
4229                                       ccode_line, vararg, (yyvsp[(3) - (11)].list));
4230                                                                         }
4231     break;
4232
4233   case 146:
4234 /* Line 1792 of yacc.c  */
4235 #line 1766 "parse.y"
4236     {
4237                         if(!has_self) {
4238                                 yyerror(_("virtual method without 'self' as "
4239                                           "first parameter"));
4240                                 free_all_global_state();
4241                                 YYERROR;
4242                         }
4243                         if(the_scope == CLASS_SCOPE) {
4244                                 yyerror(_("a method cannot be of class scope"));
4245                                 free_all_global_state();
4246                                 YYERROR;
4247                         }
4248                         if (funcattrs != NULL) {
4249                                 char *error = g_strdup_printf
4250                                         (_("function attribute macros ('%s' in this case) may not be used with virtual methods"),
4251                                          funcattrs);
4252                                 yyerror (error);
4253                                 YYERROR;
4254                         }
4255                         push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[(4) - (9)].id),
4256                                       (yyvsp[(9) - (9)].cbuf), (yyvsp[(1) - (9)].line),
4257                                       ccode_line, vararg, NULL);
4258                                                                         }
4259     break;
4260
4261   case 147:
4262 /* Line 1792 of yacc.c  */
4263 #line 1789 "parse.y"
4264     {
4265                         if(!has_self) {
4266                                 yyerror(_("virtual method without 'self' as "
4267                                           "first parameter"));
4268                                 free_all_global_state();
4269                                 YYERROR;
4270                         }
4271                         if(the_scope == CLASS_SCOPE) {
4272                                 yyerror(_("a method cannot be of class scope"));
4273                                 free_all_global_state();
4274                                 YYERROR;
4275                         }
4276                         if (funcattrs != NULL) {
4277                                 char *error = g_strdup_printf
4278                                         (_("function attribute macros ('%s' in this case) may not be used with virtual methods"),
4279                                          funcattrs);
4280                                 yyerror (error);
4281                                 YYERROR;
4282                         }
4283                         push_function(the_scope, VIRTUAL_METHOD, NULL, (yyvsp[(4) - (9)].id),
4284                                       (yyvsp[(9) - (9)].cbuf), (yyvsp[(2) - (9)].line),
4285                                       ccode_line, vararg, NULL);
4286                                                                         }
4287     break;
4288
4289   case 148:
4290 /* Line 1792 of yacc.c  */
4291 #line 1812 "parse.y"
4292     {
4293                         if(!has_self) {
4294                                 yyerror(_("virtual method without 'szelf' as "
4295                                           "first parameter"));
4296                                 free_all_global_state();
4297                                 YYERROR;
4298                         }
4299                         if (funcattrs != NULL) {
4300                                 char *error = g_strdup_printf
4301                                         (_("function attribute macros ('%s' in this case) may not be used with virtual methods"),
4302                                          funcattrs);
4303                                 yyerror (error);
4304                                 YYERROR;
4305                         }
4306                         push_function(PUBLIC_SCOPE, VIRTUAL_METHOD, NULL,
4307                                       (yyvsp[(3) - (8)].id), (yyvsp[(8) - (8)].cbuf), (yyvsp[(1) - (8)].line),
4308                                       ccode_line, vararg, NULL);
4309                                                                         }
4310     break;
4311
4312   case 149:
4313 /* Line 1792 of yacc.c  */
4314 #line 1830 "parse.y"
4315     {
4316                         if (funcattrs != NULL) {
4317                                 char *error = g_strdup_printf
4318                                         (_("function attribute macros ('%s' in this case) may not be used with override methods"),
4319                                          funcattrs);
4320                                 yyerror (error);
4321                                 YYERROR;
4322                         }
4323                         push_function(NO_SCOPE, OVERRIDE_METHOD, (yyvsp[(3) - (11)].id),
4324                                       (yyvsp[(6) - (11)].id), (yyvsp[(11) - (11)].cbuf),
4325                                       (yyvsp[(1) - (11)].line), ccode_line,
4326                                       vararg, NULL);
4327                                                                         }
4328     break;
4329
4330   case 150:
4331 /* Line 1792 of yacc.c  */
4332 #line 1843 "parse.y"
4333     {
4334                         if(the_scope == CLASS_SCOPE) {
4335                                 yyerror(_("a method cannot be of class scope"));
4336                                 free_all_global_state();
4337                                 YYERROR;
4338                         }
4339                         push_function(the_scope, REGULAR_METHOD, NULL, (yyvsp[(3) - (8)].id),
4340                                       (yyvsp[(8) - (8)].cbuf), (yyvsp[(1) - (8)].line), ccode_line,
4341                                       vararg, NULL);
4342                                                                 }
4343     break;
4344
4345   case 151:
4346 /* Line 1792 of yacc.c  */
4347 #line 1853 "parse.y"
4348     {
4349                         if(strcmp((yyvsp[(1) - (5)].id), "init")==0) {
4350                                 push_init_arg((yyvsp[(3) - (5)].id),FALSE);
4351                                 push_function(NO_SCOPE, INIT_METHOD, NULL,
4352                                               (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
4353                                               ccode_line, FALSE, NULL);
4354                         } else if(strcmp((yyvsp[(1) - (5)].id), "class_init")==0) {
4355                                 push_init_arg((yyvsp[(3) - (5)].id),TRUE);
4356                                 push_function(NO_SCOPE, CLASS_INIT_METHOD, NULL,
4357                                               (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
4358                                               ccode_line, FALSE, NULL);
4359                         } else if(strcmp((yyvsp[(1) - (5)].id), "constructor")==0) {
4360                                 push_init_arg((yyvsp[(3) - (5)].id), FALSE);
4361                                 push_function(NO_SCOPE, CONSTRUCTOR_METHOD, NULL,
4362                                               (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
4363                                               ccode_line, FALSE, NULL);
4364                         } else if(strcmp((yyvsp[(1) - (5)].id), "dispose")==0) {
4365                                 push_init_arg((yyvsp[(3) - (5)].id), FALSE);
4366                                 push_function(NO_SCOPE, DISPOSE_METHOD, NULL,
4367                                               (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
4368                                               ccode_line, FALSE, NULL);
4369                         } else if(strcmp((yyvsp[(1) - (5)].id), "finalize")==0) {
4370                                 push_init_arg((yyvsp[(3) - (5)].id), FALSE);
4371                                 push_function(NO_SCOPE, FINALIZE_METHOD, NULL,
4372                                               (yyvsp[(1) - (5)].id), (yyvsp[(5) - (5)].cbuf), (yyvsp[(2) - (5)].line),
4373                                               ccode_line, FALSE, NULL);
4374
4375                         } else {
4376                                 g_free((yyvsp[(1) - (5)].id));
4377                                 g_free((yyvsp[(3) - (5)].id));
4378                                 g_string_free((yyvsp[(5) - (5)].cbuf),TRUE);
4379                                 yyerror(_("parse error "
4380                                           "(untyped blocks must be init, "
4381                                           "class_init, constructor, dispose "
4382                                           "or finalize)"));
4383                                 YYERROR;
4384                         }
4385                                                 }
4386     break;
4387
4388   case 152:
4389 /* Line 1792 of yacc.c  */
4390 #line 1893 "parse.y"
4391     {
4392                         g_free(funcattrs); funcattrs = NULL;
4393                         g_free(onerror); onerror = NULL;
4394                         g_free(defreturn); defreturn = NULL;
4395                         if(!set_attr_value((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id))) {
4396                                 g_free((yyvsp[(1) - (2)].id));
4397                                 g_free((yyvsp[(2) - (2)].id));
4398                                 yyerror(_("parse error"));
4399                                 YYERROR;
4400                         }
4401                         g_free((yyvsp[(1) - (2)].id));
4402                                         }
4403     break;
4404
4405   case 153:
4406 /* Line 1792 of yacc.c  */
4407 #line 1905 "parse.y"
4408     {
4409                         g_free(funcattrs); funcattrs = NULL;
4410                         g_free(onerror); onerror = NULL;
4411                         g_free(defreturn); defreturn = NULL;
4412                         if(!set_attr_value((yyvsp[(1) - (4)].id), (yyvsp[(2) - (4)].id))) {
4413                                 g_free((yyvsp[(1) - (4)].id)); g_free((yyvsp[(2) - (4)].id));
4414                                 g_free((yyvsp[(3) - (4)].id)); g_free((yyvsp[(4) - (4)].id));
4415                                 yyerror(_("parse error"));
4416                                 YYERROR;
4417                         }
4418                         if(!set_attr_value((yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id))) {
4419                                 funcattrs = onerror = defreturn = NULL;
4420                                 g_free((yyvsp[(1) - (4)].id)); g_free((yyvsp[(2) - (4)].id));
4421                                 g_free((yyvsp[(3) - (4)].id)); g_free((yyvsp[(4) - (4)].id));
4422                                 yyerror(_("parse error"));
4423                                 YYERROR;
4424                         }
4425                         g_free((yyvsp[(1) - (4)].id));
4426                         g_free((yyvsp[(3) - (4)].id));
4427                                                 }
4428     break;
4429
4430   case 154:
4431 /* Line 1792 of yacc.c  */
4432 #line 1925 "parse.y"
4433     {
4434                         g_free(funcattrs); funcattrs = NULL;
4435                         g_free(onerror); onerror = NULL;
4436                         g_free(defreturn); defreturn = NULL;
4437                         if(!set_attr_value((yyvsp[(1) - (6)].id), (yyvsp[(2) - (6)].id))) {
4438                                 g_free((yyvsp[(1) - (6)].id)); g_free((yyvsp[(2) - (6)].id));
4439                                 g_free((yyvsp[(3) - (6)].id)); g_free((yyvsp[(4) - (6)].id));
4440                                 g_free((yyvsp[(5) - (6)].id)); g_free((yyvsp[(6) - (6)].id));
4441                                 yyerror(_("parse error"));
4442                                 YYERROR;
4443                         }
4444                         if(!set_attr_value((yyvsp[(3) - (6)].id), (yyvsp[(4) - (6)].id))) {
4445                                 funcattrs = onerror = defreturn = NULL;
4446                                 g_free((yyvsp[(1) - (6)].id)); g_free((yyvsp[(2) - (6)].id));
4447                                 g_free((yyvsp[(3) - (6)].id)); g_free((yyvsp[(4) - (6)].id));
4448                                 g_free((yyvsp[(5) - (6)].id)); g_free((yyvsp[(6) - (6)].id));
4449                                 yyerror(_("parse error"));
4450                                 YYERROR;
4451                         }
4452                         if(!set_attr_value((yyvsp[(5) - (6)].id), (yyvsp[(6) - (6)].id))) {
4453                                 funcattrs = onerror = defreturn = NULL;
4454                                 g_free((yyvsp[(1) - (6)].id)); g_free((yyvsp[(2) - (6)].id));
4455                                 g_free((yyvsp[(3) - (6)].id)); g_free((yyvsp[(4) - (6)].id));
4456                                 g_free((yyvsp[(5) - (6)].id)); g_free((yyvsp[(6) - (6)].id));
4457                                 yyerror(_("parse error"));
4458                                 YYERROR;
4459                         }
4460                         g_free((yyvsp[(1) - (6)].id));
4461                         g_free((yyvsp[(3) - (6)].id));
4462                         g_free((yyvsp[(5) - (6)].id));
4463                                                 }
4464     break;
4465
4466   case 155:
4467 /* Line 1792 of yacc.c  */
4468 #line 1956 "parse.y"
4469     {
4470                         g_free(funcattrs); funcattrs = NULL;
4471                         g_free(onerror); onerror = NULL;
4472                         g_free(defreturn); defreturn = NULL;
4473                                         }
4474     break;
4475
4476   case 156:
4477 /* Line 1792 of yacc.c  */
4478 #line 1963 "parse.y"
4479     { (yyval.id) = (yyvsp[(1) - (1)].id); }
4480     break;
4481
4482   case 157:
4483 /* Line 1792 of yacc.c  */
4484 #line 1964 "parse.y"
4485     {
4486                         (yyval.id) = ((yyvsp[(2) - (2)].cbuf))->str;
4487                         g_string_free((yyvsp[(2) - (2)].cbuf), FALSE);
4488                                         }
4489     break;
4490
4491   case 158:
4492 /* Line 1792 of yacc.c  */
4493 #line 1970 "parse.y"
4494     { vararg = FALSE; has_self = FALSE; }
4495     break;
4496
4497   case 159:
4498 /* Line 1792 of yacc.c  */
4499 #line 1971 "parse.y"
4500     {
4501                         vararg = FALSE;
4502                         has_self = TRUE;
4503                         if(strcmp((yyvsp[(1) - (1)].id),"self")==0)
4504                                 push_self((yyvsp[(1) - (1)].id), FALSE);
4505                         else {
4506                                 g_free((yyvsp[(1) - (1)].id));
4507                                 yyerror(_("parse error"));
4508                                 YYERROR;
4509                         }
4510                                         }
4511     break;
4512
4513   case 160:
4514 /* Line 1792 of yacc.c  */
4515 #line 1982 "parse.y"
4516     {
4517                         vararg = FALSE;
4518                         has_self = TRUE;
4519                         if(strcmp((yyvsp[(1) - (2)].id),"self")==0)
4520                                 push_self((yyvsp[(1) - (2)].id), TRUE);
4521                         else {
4522                                 g_free((yyvsp[(1) - (2)].id));
4523                                 yyerror(_("parse error"));
4524                                 YYERROR;
4525                         }
4526                                         }
4527     break;
4528
4529   case 161:
4530 /* Line 1792 of yacc.c  */
4531 #line 1993 "parse.y"
4532     {
4533                         vararg = FALSE;
4534                         has_self = TRUE;
4535                         if(strcmp((yyvsp[(2) - (2)].id),"self")==0)
4536                                 push_self((yyvsp[(2) - (2)].id), TRUE);
4537                         else {
4538                                 g_free((yyvsp[(2) - (2)].id));
4539                                 yyerror(_("parse error"));
4540                                 YYERROR;
4541                         }
4542                                         }
4543     break;
4544
4545   case 162:
4546 /* Line 1792 of yacc.c  */
4547 #line 2004 "parse.y"
4548     {
4549                         has_self = TRUE;
4550                         if(strcmp((yyvsp[(1) - (3)].id),"self")==0)
4551                                 push_self((yyvsp[(1) - (3)].id), FALSE);
4552                         else {
4553                                 g_free((yyvsp[(1) - (3)].id));
4554                                 yyerror(_("parse error"));
4555                                 YYERROR;
4556                         }
4557                                         }
4558     break;
4559
4560   case 163:
4561 /* Line 1792 of yacc.c  */
4562 #line 2014 "parse.y"
4563     {
4564                         has_self = TRUE;
4565                         if(strcmp((yyvsp[(1) - (4)].id),"self")==0)
4566                                 push_self((yyvsp[(1) - (4)].id), TRUE);
4567                         else {
4568                                 g_free((yyvsp[(1) - (4)].id));
4569                                 yyerror(_("parse error"));
4570                                 YYERROR;
4571                         }
4572                                         }
4573     break;
4574
4575   case 164:
4576 /* Line 1792 of yacc.c  */
4577 #line 2024 "parse.y"
4578     {
4579                         has_self = TRUE;
4580                         if(strcmp((yyvsp[(2) - (4)].id),"self")==0)
4581                                 push_self((yyvsp[(2) - (4)].id), TRUE);
4582                         else {
4583                                 g_free((yyvsp[(2) - (4)].id));
4584                                 yyerror(_("parse error"));
4585                                 YYERROR;
4586                         }
4587                                         }
4588     break;
4589
4590   case 165:
4591 /* Line 1792 of yacc.c  */
4592 #line 2034 "parse.y"
4593     { has_self = FALSE; }
4594     break;
4595
4596   case 166:
4597 /* Line 1792 of yacc.c  */
4598 #line 2037 "parse.y"
4599     { vararg = TRUE; }
4600     break;
4601
4602   case 167:
4603 /* Line 1792 of yacc.c  */
4604 #line 2038 "parse.y"
4605     { vararg = FALSE; }
4606     break;
4607
4608   case 168:
4609 /* Line 1792 of yacc.c  */
4610 #line 2041 "parse.y"
4611     { ; }
4612     break;
4613
4614   case 169:
4615 /* Line 1792 of yacc.c  */
4616 #line 2042 "parse.y"
4617     { ; }
4618     break;
4619
4620   case 170:
4621 /* Line 1792 of yacc.c  */
4622 #line 2045 "parse.y"
4623     {
4624                         push_funcarg((yyvsp[(2) - (2)].id),NULL);
4625                                                                 }
4626     break;
4627
4628   case 171:
4629 /* Line 1792 of yacc.c  */
4630 #line 2048 "parse.y"
4631     {
4632                         push_funcarg((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].id));
4633                                                                 }
4634     break;
4635
4636   case 172:
4637 /* Line 1792 of yacc.c  */
4638 #line 2051 "parse.y"
4639     {
4640                         if(strcmp((yyvsp[(4) - (6)].id),"check")!=0) {
4641                                 yyerror(_("parse error"));
4642                                 YYERROR;
4643                         }
4644                         g_free((yyvsp[(4) - (6)].id));
4645                         push_funcarg((yyvsp[(2) - (6)].id),NULL);
4646                                                                 }
4647     break;
4648
4649   case 173:
4650 /* Line 1792 of yacc.c  */
4651 #line 2059 "parse.y"
4652     {
4653                         if(strcmp((yyvsp[(5) - (7)].id),"check")!=0) {
4654                                 yyerror(_("parse error"));
4655                                 YYERROR;
4656                         }
4657                         g_free((yyvsp[(5) - (7)].id));
4658                         push_funcarg((yyvsp[(2) - (7)].id),(yyvsp[(3) - (7)].id));
4659                                                                 }
4660     break;
4661
4662   case 174:
4663 /* Line 1792 of yacc.c  */
4664 #line 2069 "parse.y"
4665     { ; }
4666     break;
4667
4668   case 175:
4669 /* Line 1792 of yacc.c  */
4670 #line 2070 "parse.y"
4671     { ; }
4672     break;
4673
4674   case 176:
4675 /* Line 1792 of yacc.c  */
4676 #line 2073 "parse.y"
4677     {
4678                         if(strcmp((yyvsp[(1) - (1)].id),"type")==0) {
4679                                 Node *node = node_new (CHECK_NODE,
4680                                                        "chtype", TYPE_CHECK,
4681                                                        NULL);
4682                                 checks = g_list_append(checks,node);
4683                         } else if(strcmp((yyvsp[(1) - (1)].id),"null")==0) {
4684                                 Node *node = node_new (CHECK_NODE,
4685                                                        "chtype", NULL_CHECK,
4686                                                        NULL);
4687                                 checks = g_list_append(checks,node);
4688                         } else {
4689                                 yyerror(_("parse error"));
4690                                 YYERROR;
4691                         }
4692                         g_free((yyvsp[(1) - (1)].id));
4693                                         }
4694     break;
4695
4696   case 177:
4697 /* Line 1792 of yacc.c  */
4698 #line 2090 "parse.y"
4699     {
4700                         Node *node = node_new (CHECK_NODE,
4701                                                "chtype", GT_CHECK,
4702                                                "number:steal", (yyvsp[(2) - (2)].id),
4703                                                NULL);
4704                         checks = g_list_append(checks,node);
4705                                         }
4706     break;
4707
4708   case 178:
4709 /* Line 1792 of yacc.c  */
4710 #line 2097 "parse.y"
4711     {
4712                         Node *node = node_new (CHECK_NODE,
4713                                                "chtype", LT_CHECK,
4714                                                "number:steal", (yyvsp[(2) - (2)].id),
4715                                                NULL);
4716                         checks = g_list_append(checks,node);
4717                                         }
4718     break;
4719
4720   case 179:
4721 /* Line 1792 of yacc.c  */
4722 #line 2104 "parse.y"
4723     {
4724                         Node *node = node_new (CHECK_NODE,
4725                                                "chtype", GE_CHECK,
4726                                                "number:steal", (yyvsp[(3) - (3)].id),
4727                                                NULL);
4728                         checks = g_list_append(checks,node);
4729                                         }
4730     break;
4731
4732   case 180:
4733 /* Line 1792 of yacc.c  */
4734 #line 2111 "parse.y"
4735     {
4736                         Node *node = node_new (CHECK_NODE,
4737                                                "chtype", LE_CHECK,
4738                                                "number:steal", (yyvsp[(3) - (3)].id),
4739                                                NULL);
4740                         checks = g_list_append(checks,node);
4741                                         }
4742     break;
4743
4744   case 181:
4745 /* Line 1792 of yacc.c  */
4746 #line 2118 "parse.y"
4747     {
4748                         Node *node = node_new (CHECK_NODE,
4749                                                "chtype", EQ_CHECK,
4750                                                "number:steal", (yyvsp[(3) - (3)].id),
4751                                                NULL);
4752                         checks = g_list_append(checks,node);
4753                                         }
4754     break;
4755
4756   case 182:
4757 /* Line 1792 of yacc.c  */
4758 #line 2125 "parse.y"
4759     {
4760                         Node *node = node_new (CHECK_NODE,
4761                                                "chtype", NE_CHECK,
4762                                                "number:steal", (yyvsp[(3) - (3)].id),
4763                                                NULL);
4764                         checks = g_list_append(checks,node);
4765                                         }
4766     break;
4767
4768   case 183:
4769 /* Line 1792 of yacc.c  */
4770 #line 2134 "parse.y"
4771     {
4772                         Node *node = node_new (ENUMDEF_NODE,
4773                                                "etype:steal", (yyvsp[(6) - (7)].id),
4774                                                "prefix:steal", (yyvsp[(2) - (7)].id),
4775                                                "values:steal", enum_vals,
4776                                                NULL);
4777                         enum_vals = NULL;
4778                         nodes = g_list_append (nodes, node);
4779                         }
4780     break;
4781
4782   case 184:
4783 /* Line 1792 of yacc.c  */
4784 #line 2143 "parse.y"
4785     {
4786                         Node *node = node_new (ENUMDEF_NODE,
4787                                                "etype:steal", (yyvsp[(7) - (8)].id),
4788                                                "prefix:steal", (yyvsp[(2) - (8)].id),
4789                                                "values:steal", enum_vals,
4790                                                NULL);
4791                         enum_vals = NULL;
4792                         nodes = g_list_append (nodes, node);
4793                         }
4794     break;
4795
4796   case 185:
4797 /* Line 1792 of yacc.c  */
4798 #line 2154 "parse.y"
4799     {;}
4800     break;
4801
4802   case 186:
4803 /* Line 1792 of yacc.c  */
4804 #line 2155 "parse.y"
4805     {;}
4806     break;
4807
4808   case 187:
4809 /* Line 1792 of yacc.c  */
4810 #line 2158 "parse.y"
4811     {
4812                         Node *node;
4813                         char *num = (yyvsp[(3) - (3)].id);
4814
4815                         /* A float value, that's a bad enum */
4816                         if (num[0] >= '0' &&
4817                             num[0] <= '9' &&
4818                             strchr (num, '.') != NULL) {
4819                                 g_free ((yyvsp[(1) - (3)].id));
4820                                 g_free (num);
4821                                 yyerror(_("parse error (enumerator value not integer constant)"));
4822                                 YYERROR;
4823                         }
4824
4825                         node = node_new (ENUMVALUE_NODE,
4826                                          "name:steal", (yyvsp[(1) - (3)].id),
4827                                          "value:steal", num,
4828                                          NULL);
4829                         enum_vals = g_list_append (enum_vals, node);
4830                         }
4831     break;
4832
4833   case 188:
4834 /* Line 1792 of yacc.c  */
4835 #line 2178 "parse.y"
4836     {
4837                         Node *node;
4838
4839                         node = node_new (ENUMVALUE_NODE,
4840                                          "name:steal", (yyvsp[(1) - (1)].id),
4841                                          NULL);
4842                         enum_vals = g_list_append (enum_vals, node);
4843         }
4844     break;
4845
4846   case 189:
4847 /* Line 1792 of yacc.c  */
4848 #line 2188 "parse.y"
4849     {
4850                         Node *node = node_new (FLAGS_NODE,
4851                                                "ftype:steal", (yyvsp[(6) - (7)].id),
4852                                                "prefix:steal", (yyvsp[(2) - (7)].id),
4853                                                "values:steal", flag_vals,
4854                                                NULL);
4855                         flag_vals = NULL;
4856                         nodes = g_list_append (nodes, node);
4857                         }
4858     break;
4859
4860   case 190:
4861 /* Line 1792 of yacc.c  */
4862 #line 2197 "parse.y"
4863     {
4864                         Node *node = node_new (FLAGS_NODE,
4865                                                "ftype:steal", (yyvsp[(7) - (8)].id),
4866                                                "prefix:steal", (yyvsp[(2) - (8)].id),
4867                                                "values:steal", flag_vals,
4868                                                NULL);
4869                         flag_vals = NULL;
4870                         nodes = g_list_append (nodes, node);
4871                         }
4872     break;
4873
4874   case 191:
4875 /* Line 1792 of yacc.c  */
4876 #line 2208 "parse.y"
4877     {
4878                         flag_vals = g_list_append (flag_vals, (yyvsp[(3) - (3)].id));
4879                 }
4880     break;
4881
4882   case 192:
4883 /* Line 1792 of yacc.c  */
4884 #line 2211 "parse.y"
4885     {
4886                         flag_vals = g_list_append (flag_vals, (yyvsp[(1) - (1)].id));
4887                 }
4888     break;
4889
4890   case 193:
4891 /* Line 1792 of yacc.c  */
4892 #line 2216 "parse.y"
4893     {
4894                         Node *node = node_new (ERROR_NODE,
4895                                                "etype:steal", (yyvsp[(6) - (7)].id),
4896                                                "prefix:steal", (yyvsp[(2) - (7)].id),
4897                                                "values:steal", error_vals,
4898                                                NULL);
4899                         error_vals = NULL;
4900                         nodes = g_list_append (nodes, node);
4901                         }
4902     break;
4903
4904   case 194:
4905 /* Line 1792 of yacc.c  */
4906 #line 2225 "parse.y"
4907     {
4908                         Node *node = node_new (ERROR_NODE,
4909                                                "etype:steal", (yyvsp[(7) - (8)].id),
4910                                                "prefix:steal", (yyvsp[(2) - (8)].id),
4911                                                "values:steal", error_vals,
4912                                                NULL);
4913                         error_vals = NULL;
4914                         nodes = g_list_append (nodes, node);
4915                         }
4916     break;
4917
4918   case 195:
4919 /* Line 1792 of yacc.c  */
4920 #line 2236 "parse.y"
4921     {
4922                         error_vals = g_list_append (error_vals, (yyvsp[(3) - (3)].id));
4923                 }
4924     break;
4925
4926   case 196:
4927 /* Line 1792 of yacc.c  */
4928 #line 2239 "parse.y"
4929     {
4930                         error_vals = g_list_append (error_vals, (yyvsp[(1) - (1)].id));
4931                 }
4932     break;
4933
4934   case 197:
4935 /* Line 1792 of yacc.c  */
4936 #line 2245 "parse.y"
4937     { (yyval.id) = (yyvsp[(1) - (1)].id); }
4938     break;
4939
4940   case 198:
4941 /* Line 1792 of yacc.c  */
4942 #line 2246 "parse.y"
4943     {
4944                         (yyval.id) = g_strconcat("-",(yyvsp[(2) - (2)].id),NULL);
4945                         g_free((yyvsp[(2) - (2)].id));
4946                                         }
4947     break;
4948
4949   case 199:
4950 /* Line 1792 of yacc.c  */
4951 #line 2250 "parse.y"
4952     { (yyval.id) = (yyvsp[(1) - (1)].id); }
4953     break;
4954
4955   case 200:
4956 /* Line 1792 of yacc.c  */
4957 #line 2251 "parse.y"
4958     { (yyval.id) = (yyvsp[(1) - (1)].id); }
4959     break;
4960
4961
4962 /* Line 1792 of yacc.c  */
4963 #line 4964 "parse.c"
4964       default: break;
4965     }
4966   /* User semantic actions sometimes alter yychar, and that requires
4967      that yytoken be updated with the new translation.  We take the
4968      approach of translating immediately before every use of yytoken.
4969      One alternative is translating here after every semantic action,
4970      but that translation would be missed if the semantic action invokes
4971      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4972      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
4973      incorrect destructor might then be invoked immediately.  In the
4974      case of YYERROR or YYBACKUP, subsequent parser actions might lead
4975      to an incorrect destructor call or verbose syntax error message
4976      before the lookahead is translated.  */
4977   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4978
4979   YYPOPSTACK (yylen);
4980   yylen = 0;
4981   YY_STACK_PRINT (yyss, yyssp);
4982
4983   *++yyvsp = yyval;
4984
4985   /* Now `shift' the result of the reduction.  Determine what state
4986      that goes to, based on the state we popped back to and the rule
4987      number reduced by.  */
4988
4989   yyn = yyr1[yyn];
4990
4991   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4992   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4993     yystate = yytable[yystate];
4994   else
4995     yystate = yydefgoto[yyn - YYNTOKENS];
4996
4997   goto yynewstate;
4998
4999
5000 /*------------------------------------.
5001 | yyerrlab -- here on detecting error |
5002 `------------------------------------*/
5003 yyerrlab:
5004   /* Make sure we have latest lookahead translation.  See comments at
5005      user semantic actions for why this is necessary.  */
5006   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
5007
5008   /* If not already recovering from an error, report this error.  */
5009   if (!yyerrstatus)
5010     {
5011       ++yynerrs;
5012 #if ! YYERROR_VERBOSE
5013       yyerror (YY_("syntax error"));
5014 #else
5015 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
5016                                         yyssp, yytoken)
5017       {
5018         char const *yymsgp = YY_("syntax error");
5019         int yysyntax_error_status;
5020         yysyntax_error_status = YYSYNTAX_ERROR;
5021         if (yysyntax_error_status == 0)
5022           yymsgp = yymsg;
5023         else if (yysyntax_error_status == 1)
5024           {
5025             if (yymsg != yymsgbuf)
5026               YYSTACK_FREE (yymsg);
5027             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
5028             if (!yymsg)
5029               {
5030                 yymsg = yymsgbuf;
5031                 yymsg_alloc = sizeof yymsgbuf;
5032                 yysyntax_error_status = 2;
5033               }
5034             else
5035               {
5036                 yysyntax_error_status = YYSYNTAX_ERROR;
5037                 yymsgp = yymsg;
5038               }
5039           }
5040         yyerror (yymsgp);
5041         if (yysyntax_error_status == 2)
5042           goto yyexhaustedlab;
5043       }
5044 # undef YYSYNTAX_ERROR
5045 #endif
5046     }
5047
5048
5049
5050   if (yyerrstatus == 3)
5051     {
5052       /* If just tried and failed to reuse lookahead token after an
5053          error, discard it.  */
5054
5055       if (yychar <= YYEOF)
5056         {
5057           /* Return failure if at end of input.  */
5058           if (yychar == YYEOF)
5059             YYABORT;
5060         }
5061       else
5062         {
5063           yydestruct ("Error: discarding",
5064                       yytoken, &yylval);
5065           yychar = YYEMPTY;
5066         }
5067     }
5068
5069   /* Else will try to reuse lookahead token after shifting the error
5070      token.  */
5071   goto yyerrlab1;
5072
5073
5074 /*---------------------------------------------------.
5075 | yyerrorlab -- error raised explicitly by YYERROR.  |
5076 `---------------------------------------------------*/
5077 yyerrorlab:
5078
5079   /* Pacify compilers like GCC when the user code never invokes
5080      YYERROR and the label yyerrorlab therefore never appears in user
5081      code.  */
5082   if (/*CONSTCOND*/ 0)
5083      goto yyerrorlab;
5084
5085   /* Do not reclaim the symbols of the rule which action triggered
5086      this YYERROR.  */
5087   YYPOPSTACK (yylen);
5088   yylen = 0;
5089   YY_STACK_PRINT (yyss, yyssp);
5090   yystate = *yyssp;
5091   goto yyerrlab1;
5092
5093
5094 /*-------------------------------------------------------------.
5095 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
5096 `-------------------------------------------------------------*/
5097 yyerrlab1:
5098   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
5099
5100   for (;;)
5101     {
5102       yyn = yypact[yystate];
5103       if (!yypact_value_is_default (yyn))
5104         {
5105           yyn += YYTERROR;
5106           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
5107             {
5108               yyn = yytable[yyn];
5109               if (0 < yyn)
5110                 break;
5111             }
5112         }
5113
5114       /* Pop the current state because it cannot handle the error token.  */
5115       if (yyssp == yyss)
5116         YYABORT;
5117
5118
5119       yydestruct ("Error: popping",
5120                   yystos[yystate], yyvsp);
5121       YYPOPSTACK (1);
5122       yystate = *yyssp;
5123       YY_STACK_PRINT (yyss, yyssp);
5124     }
5125
5126   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5127   *++yyvsp = yylval;
5128   YY_IGNORE_MAYBE_UNINITIALIZED_END
5129
5130
5131   /* Shift the error token.  */
5132   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
5133
5134   yystate = yyn;
5135   goto yynewstate;
5136
5137
5138 /*-------------------------------------.
5139 | yyacceptlab -- YYACCEPT comes here.  |
5140 `-------------------------------------*/
5141 yyacceptlab:
5142   yyresult = 0;
5143   goto yyreturn;
5144
5145 /*-----------------------------------.
5146 | yyabortlab -- YYABORT comes here.  |
5147 `-----------------------------------*/
5148 yyabortlab:
5149   yyresult = 1;
5150   goto yyreturn;
5151
5152 #if !defined yyoverflow || YYERROR_VERBOSE
5153 /*-------------------------------------------------.
5154 | yyexhaustedlab -- memory exhaustion comes here.  |
5155 `-------------------------------------------------*/
5156 yyexhaustedlab:
5157   yyerror (YY_("memory exhausted"));
5158   yyresult = 2;
5159   /* Fall through.  */
5160 #endif
5161
5162 yyreturn:
5163   if (yychar != YYEMPTY)
5164     {
5165       /* Make sure we have latest lookahead translation.  See comments at
5166          user semantic actions for why this is necessary.  */
5167       yytoken = YYTRANSLATE (yychar);
5168       yydestruct ("Cleanup: discarding lookahead",
5169                   yytoken, &yylval);
5170     }
5171   /* Do not reclaim the symbols of the rule which action triggered
5172      this YYABORT or YYACCEPT.  */
5173   YYPOPSTACK (yylen);
5174   YY_STACK_PRINT (yyss, yyssp);
5175   while (yyssp != yyss)
5176     {
5177       yydestruct ("Cleanup: popping",
5178                   yystos[*yyssp], yyvsp);
5179       YYPOPSTACK (1);
5180     }
5181 #ifndef yyoverflow
5182   if (yyss != yyssa)
5183     YYSTACK_FREE (yyss);
5184 #endif
5185 #if YYERROR_VERBOSE
5186   if (yymsg != yymsgbuf)
5187     YYSTACK_FREE (yymsg);
5188 #endif
5189   /* Make sure YYID is used.  */
5190   return YYID (yyresult);
5191 }
5192
5193
5194 /* Line 2055 of yacc.c  */
5195 #line 2254 "parse.y"
5196