src/parse.c

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