src/parse.c

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