src/treefuncs.c

   1 /* Generated by generate_treefuncs.pl from treefuncs.def!
   2  * Do not edit by hand! */
   3
   4 #include <glib.h>
   5 #include <stdarg.h>
   6 #include "treefuncs.h"
   7
   8 #define COPY_LIST_VALS(list,func) { GList *li; for (li=(list);li;li=li->next) { li->data=func (li->data); } }
   9
  10 static Argument *
  11 copy_argument (Argument * self);
  12 static CCode *
  13 copy_ccode (CCode * self);
  14 static Check *
  15 copy_check (Check * self);
  16 static Class *
  17 copy_class (Class * self);
  18 static FuncArg *
  19 copy_funcarg (FuncArg * self);
  20 static Method *
  21 copy_method (Method * self);
  22 static Property *
  23 copy_property (Property * self);
  24 static Type *
  25 copy_type (Type * self);
  26 static Variable *
  27 copy_variable (Variable * self);
  28
  29 void
  30 free_argument (Argument * self);
  31 void
  32 free_ccode (CCode * self);
  33 void
  34 free_check (Check * self);
  35 void
  36 free_class (Class * self);
  37 void
  38 free_funcarg (FuncArg * self);
  39 void
  40 free_method (Method * self);
  41 void
  42 free_property (Property * self);
  43 void
  44 free_type (Type * self);
  45 void
  46 free_variable (Variable * self);
  47
  48 static void
  49 setv_argument (Argument * self, va_list __ap);
  50 static void
  51 setv_ccode (CCode * self, va_list __ap);
  52 static void
  53 setv_check (Check * self, va_list __ap);
  54 static void
  55 setv_class (Class * self, va_list __ap);
  56 static void
  57 setv_funcarg (FuncArg * self, va_list __ap);
  58 static void
  59 setv_method (Method * self, va_list __ap);
  60 static void
  61 setv_property (Property * self, va_list __ap);
  62 static void
  63 setv_type (Type * self, va_list __ap);
  64 static void
  65 setv_variable (Variable * self, va_list __ap);
  66
  67 static gboolean quarks_set_up = FALSE;
  68 static GHashTable *quark_ht;
  69 enum {
  70         QUARK_0,
  71         QUARK_otype,
  72         QUARK_otype_STEAL,
  73         QUARK_ptype,
  74         QUARK_ptype_STEAL,
  75         QUARK_bonobo_x_class,
  76         QUARK_bonobo_x_class_STEAL,
  77         QUARK_chunk_size,
  78         QUARK_chunk_size_STEAL,
  79         QUARK_nodes,
  80         QUARK_nodes_STEAL,
  81         QUARK_name,
  82         QUARK_name_STEAL,
  83         QUARK_pointer,
  84         QUARK_pointer_STEAL,
  85         QUARK_postfix,
  86         QUARK_postfix_STEAL,
  87         QUARK_cctype,
  88         QUARK_cbuf,
  89         QUARK_cbuf_STEAL,
  90         QUARK_line_no,
  91         QUARK_chtype,
  92         QUARK_number,
  93         QUARK_number_STEAL,
  94         QUARK_atype,
  95         QUARK_atype_STEAL,
  96         QUARK_checks,
  97         QUARK_checks_STEAL,
  98         QUARK_gtktype,
  99         QUARK_gtktype_STEAL,
 100         QUARK_flags,
 101         QUARK_flags_STEAL,
 102         QUARK_get,
 103         QUARK_get_STEAL,
 104         QUARK_get_line,
 105         QUARK_set,
 106         QUARK_set_STEAL,
 107         QUARK_set_line,
 108         QUARK_nick,
 109         QUARK_nick_STEAL,
 110         QUARK_blurb,
 111         QUARK_blurb_STEAL,
 112         QUARK_minimum,
 113         QUARK_minimum_STEAL,
 114         QUARK_maximum,
 115         QUARK_maximum_STEAL,
 116         QUARK_default_value,
 117         QUARK_default_value_STEAL,
 118         QUARK_extra_gtktype,
 119         QUARK_extra_gtktype_STEAL,
 120         QUARK_link,
 121         QUARK_export,
 122         QUARK_scope,
 123         QUARK_method,
 124         QUARK_mtype,
 125         QUARK_mtype_STEAL,
 126         QUARK_gtktypes,
 127         QUARK_gtktypes_STEAL,
 128         QUARK_id,
 129         QUARK_id_STEAL,
 130         QUARK_args,
 131         QUARK_args_STEAL,
 132         QUARK_onerror,
 133         QUARK_onerror_STEAL,
 134         QUARK_defreturn,
 135         QUARK_defreturn_STEAL,
 136         QUARK_ccode_line,
 137         QUARK_vararg,
 138         QUARK_unique_id,
 139         QUARK_bonobo_x_func,
 140         QUARK_vtype,
 141         QUARK_vtype_STEAL,
 142         QUARK_destructor_unref,
 143         QUARK_destructor,
 144         QUARK_destructor_STEAL,
 145         QUARK_destructor_line,
 146         QUARK_destructor_simple,
 147         QUARK_initializer,
 148         QUARK_initializer_STEAL,
 149         QUARK_initializer_line,
 150         QUARK_LAST
 151 };
 152
 153 static void
 154 ensure_quarks (void)
 155 {
 156         if (quarks_set_up)
 157                 return;
 158         quark_ht = g_hash_table_new (g_str_hash, g_str_equal);
 159         quarks_set_up = TRUE;
 160         g_hash_table_insert (quark_ht, "otype", GINT_TO_POINTER (QUARK_otype));
 161         g_hash_table_insert (quark_ht, "otype:steal", GINT_TO_POINTER (QUARK_otype_STEAL));
 162         g_hash_table_insert (quark_ht, "ptype", GINT_TO_POINTER (QUARK_ptype));
 163         g_hash_table_insert (quark_ht, "ptype:steal", GINT_TO_POINTER (QUARK_ptype_STEAL));
 164         g_hash_table_insert (quark_ht, "bonobo_x_class", GINT_TO_POINTER (QUARK_bonobo_x_class));
 165         g_hash_table_insert (quark_ht, "bonobo_x_class:steal", GINT_TO_POINTER (QUARK_bonobo_x_class_STEAL));
 166         g_hash_table_insert (quark_ht, "chunk_size", GINT_TO_POINTER (QUARK_chunk_size));
 167         g_hash_table_insert (quark_ht, "chunk_size:steal", GINT_TO_POINTER (QUARK_chunk_size_STEAL));
 168         g_hash_table_insert (quark_ht, "nodes", GINT_TO_POINTER (QUARK_nodes));
 169         g_hash_table_insert (quark_ht, "nodes:steal", GINT_TO_POINTER (QUARK_nodes_STEAL));
 170         g_hash_table_insert (quark_ht, "name", GINT_TO_POINTER (QUARK_name));
 171         g_hash_table_insert (quark_ht, "name:steal", GINT_TO_POINTER (QUARK_name_STEAL));
 172         g_hash_table_insert (quark_ht, "pointer", GINT_TO_POINTER (QUARK_pointer));
 173         g_hash_table_insert (quark_ht, "pointer:steal", GINT_TO_POINTER (QUARK_pointer_STEAL));
 174         g_hash_table_insert (quark_ht, "postfix", GINT_TO_POINTER (QUARK_postfix));
 175         g_hash_table_insert (quark_ht, "postfix:steal", GINT_TO_POINTER (QUARK_postfix_STEAL));
 176         g_hash_table_insert (quark_ht, "cctype", GINT_TO_POINTER (QUARK_cctype));
 177         g_hash_table_insert (quark_ht, "cbuf", GINT_TO_POINTER (QUARK_cbuf));
 178         g_hash_table_insert (quark_ht, "cbuf:steal", GINT_TO_POINTER (QUARK_cbuf_STEAL));
 179         g_hash_table_insert (quark_ht, "line_no", GINT_TO_POINTER (QUARK_line_no));
 180         g_hash_table_insert (quark_ht, "chtype", GINT_TO_POINTER (QUARK_chtype));
 181         g_hash_table_insert (quark_ht, "number", GINT_TO_POINTER (QUARK_number));
 182         g_hash_table_insert (quark_ht, "number:steal", GINT_TO_POINTER (QUARK_number_STEAL));
 183         g_hash_table_insert (quark_ht, "atype", GINT_TO_POINTER (QUARK_atype));
 184         g_hash_table_insert (quark_ht, "atype:steal", GINT_TO_POINTER (QUARK_atype_STEAL));
 185         g_hash_table_insert (quark_ht, "checks", GINT_TO_POINTER (QUARK_checks));
 186         g_hash_table_insert (quark_ht, "checks:steal", GINT_TO_POINTER (QUARK_checks_STEAL));
 187         g_hash_table_insert (quark_ht, "gtktype", GINT_TO_POINTER (QUARK_gtktype));
 188         g_hash_table_insert (quark_ht, "gtktype:steal", GINT_TO_POINTER (QUARK_gtktype_STEAL));
 189         g_hash_table_insert (quark_ht, "flags", GINT_TO_POINTER (QUARK_flags));
 190         g_hash_table_insert (quark_ht, "flags:steal", GINT_TO_POINTER (QUARK_flags_STEAL));
 191         g_hash_table_insert (quark_ht, "get", GINT_TO_POINTER (QUARK_get));
 192         g_hash_table_insert (quark_ht, "get:steal", GINT_TO_POINTER (QUARK_get_STEAL));
 193         g_hash_table_insert (quark_ht, "get_line", GINT_TO_POINTER (QUARK_get_line));
 194         g_hash_table_insert (quark_ht, "set", GINT_TO_POINTER (QUARK_set));
 195         g_hash_table_insert (quark_ht, "set:steal", GINT_TO_POINTER (QUARK_set_STEAL));
 196         g_hash_table_insert (quark_ht, "set_line", GINT_TO_POINTER (QUARK_set_line));
 197         g_hash_table_insert (quark_ht, "nick", GINT_TO_POINTER (QUARK_nick));
 198         g_hash_table_insert (quark_ht, "nick:steal", GINT_TO_POINTER (QUARK_nick_STEAL));
 199         g_hash_table_insert (quark_ht, "blurb", GINT_TO_POINTER (QUARK_blurb));
 200         g_hash_table_insert (quark_ht, "blurb:steal", GINT_TO_POINTER (QUARK_blurb_STEAL));
 201         g_hash_table_insert (quark_ht, "minimum", GINT_TO_POINTER (QUARK_minimum));
 202         g_hash_table_insert (quark_ht, "minimum:steal", GINT_TO_POINTER (QUARK_minimum_STEAL));
 203         g_hash_table_insert (quark_ht, "maximum", GINT_TO_POINTER (QUARK_maximum));
 204         g_hash_table_insert (quark_ht, "maximum:steal", GINT_TO_POINTER (QUARK_maximum_STEAL));
 205         g_hash_table_insert (quark_ht, "default_value", GINT_TO_POINTER (QUARK_default_value));
 206         g_hash_table_insert (quark_ht, "default_value:steal", GINT_TO_POINTER (QUARK_default_value_STEAL));
 207         g_hash_table_insert (quark_ht, "extra_gtktype", GINT_TO_POINTER (QUARK_extra_gtktype));
 208         g_hash_table_insert (quark_ht, "extra_gtktype:steal", GINT_TO_POINTER (QUARK_extra_gtktype_STEAL));
 209         g_hash_table_insert (quark_ht, "link", GINT_TO_POINTER (QUARK_link));
 210         g_hash_table_insert (quark_ht, "export", GINT_TO_POINTER (QUARK_export));
 211         g_hash_table_insert (quark_ht, "scope", GINT_TO_POINTER (QUARK_scope));
 212         g_hash_table_insert (quark_ht, "method", GINT_TO_POINTER (QUARK_method));
 213         g_hash_table_insert (quark_ht, "mtype", GINT_TO_POINTER (QUARK_mtype));
 214         g_hash_table_insert (quark_ht, "mtype:steal", GINT_TO_POINTER (QUARK_mtype_STEAL));
 215         g_hash_table_insert (quark_ht, "gtktypes", GINT_TO_POINTER (QUARK_gtktypes));
 216         g_hash_table_insert (quark_ht, "gtktypes:steal", GINT_TO_POINTER (QUARK_gtktypes_STEAL));
 217         g_hash_table_insert (quark_ht, "id", GINT_TO_POINTER (QUARK_id));
 218         g_hash_table_insert (quark_ht, "id:steal", GINT_TO_POINTER (QUARK_id_STEAL));
 219         g_hash_table_insert (quark_ht, "args", GINT_TO_POINTER (QUARK_args));
 220         g_hash_table_insert (quark_ht, "args:steal", GINT_TO_POINTER (QUARK_args_STEAL));
 221         g_hash_table_insert (quark_ht, "onerror", GINT_TO_POINTER (QUARK_onerror));
 222         g_hash_table_insert (quark_ht, "onerror:steal", GINT_TO_POINTER (QUARK_onerror_STEAL));
 223         g_hash_table_insert (quark_ht, "defreturn", GINT_TO_POINTER (QUARK_defreturn));
 224         g_hash_table_insert (quark_ht, "defreturn:steal", GINT_TO_POINTER (QUARK_defreturn_STEAL));
 225         g_hash_table_insert (quark_ht, "ccode_line", GINT_TO_POINTER (QUARK_ccode_line));
 226         g_hash_table_insert (quark_ht, "vararg", GINT_TO_POINTER (QUARK_vararg));
 227         g_hash_table_insert (quark_ht, "unique_id", GINT_TO_POINTER (QUARK_unique_id));
 228         g_hash_table_insert (quark_ht, "bonobo_x_func", GINT_TO_POINTER (QUARK_bonobo_x_func));
 229         g_hash_table_insert (quark_ht, "vtype", GINT_TO_POINTER (QUARK_vtype));
 230         g_hash_table_insert (quark_ht, "vtype:steal", GINT_TO_POINTER (QUARK_vtype_STEAL));
 231         g_hash_table_insert (quark_ht, "destructor_unref", GINT_TO_POINTER (QUARK_destructor_unref));
 232         g_hash_table_insert (quark_ht, "destructor", GINT_TO_POINTER (QUARK_destructor));
 233         g_hash_table_insert (quark_ht, "destructor:steal", GINT_TO_POINTER (QUARK_destructor_STEAL));
 234         g_hash_table_insert (quark_ht, "destructor_line", GINT_TO_POINTER (QUARK_destructor_line));
 235         g_hash_table_insert (quark_ht, "destructor_simple", GINT_TO_POINTER (QUARK_destructor_simple));
 236         g_hash_table_insert (quark_ht, "initializer", GINT_TO_POINTER (QUARK_initializer));
 237         g_hash_table_insert (quark_ht, "initializer:steal", GINT_TO_POINTER (QUARK_initializer_STEAL));
 238         g_hash_table_insert (quark_ht, "initializer_line", GINT_TO_POINTER (QUARK_initializer_line));
 239 }
 240
 241 static Argument *
 242 copy_argument (Argument * self)
 243 {
 244         Argument * new;
 245         g_return_val_if_fail (self != NULL, NULL);
 246         g_return_val_if_fail (self->type == ARGUMENT_NODE, NULL);
 247         new = g_new0(Argument, 1);
 248         new->type = ARGUMENT_NODE;
 249         new->gtktype = g_strdup (self->gtktype);
 250         new->atype = copy_type (self->atype);
 251         new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 252         new->name = g_strdup (self->name);
 253         new->get = g_strdup (self->get);
 254         new->get_line = self->get_line;
 255         new->set = g_strdup (self->set);
 256         new->set_line = self->set_line;
 257         new->line_no = self->line_no;
 258         return new;
 259 }
 260
 261 static CCode *
 262 copy_ccode (CCode * self)
 263 {
 264         CCode * new;
 265         g_return_val_if_fail (self != NULL, NULL);
 266         g_return_val_if_fail (self->type == CCODE_NODE, NULL);
 267         new = g_new0(CCode, 1);
 268         new->type = CCODE_NODE;
 269         new->cctype = self->cctype;
 270         new->cbuf = g_strdup (self->cbuf);
 271         new->line_no = self->line_no;
 272         return new;
 273 }
 274
 275 static Check *
 276 copy_check (Check * self)
 277 {
 278         Check * new;
 279         g_return_val_if_fail (self != NULL, NULL);
 280         g_return_val_if_fail (self->type == CHECK_NODE, NULL);
 281         new = g_new0(Check, 1);
 282         new->type = CHECK_NODE;
 283         new->chtype = self->chtype;
 284         new->number = g_strdup (self->number);
 285         return new;
 286 }
 287
 288 static Class *
 289 copy_class (Class * self)
 290 {
 291         Class * new;
 292         g_return_val_if_fail (self != NULL, NULL);
 293         g_return_val_if_fail (self->type == CLASS_NODE, NULL);
 294         new = g_new0(Class, 1);
 295         new->type = CLASS_NODE;
 296         new->otype = g_strdup (self->otype);
 297         new->ptype = g_strdup (self->ptype);
 298         new->bonobo_x_class = g_strdup (self->bonobo_x_class);
 299         new->chunk_size = g_strdup (self->chunk_size);
 300         new->nodes = node_list_copy (self->nodes);
 301         return new;
 302 }
 303
 304 static FuncArg *
 305 copy_funcarg (FuncArg * self)
 306 {
 307         FuncArg * new;
 308         g_return_val_if_fail (self != NULL, NULL);
 309         g_return_val_if_fail (self->type == FUNCARG_NODE, NULL);
 310         new = g_new0(FuncArg, 1);
 311         new->type = FUNCARG_NODE;
 312         new->atype = copy_type (self->atype);
 313         new->name = g_strdup (self->name);
 314         new->checks = node_list_copy (self->checks);
 315         return new;
 316 }
 317
 318 static Method *
 319 copy_method (Method * self)
 320 {
 321         Method * new;
 322         g_return_val_if_fail (self != NULL, NULL);
 323         g_return_val_if_fail (self->type == METHOD_NODE, NULL);
 324         new = g_new0(Method, 1);
 325         new->type = METHOD_NODE;
 326         new->scope = self->scope;
 327         new->method = self->method;
 328         new->mtype = copy_type (self->mtype);
 329         new->otype = g_strdup (self->otype);
 330         new->gtktypes = g_list_copy (self->gtktypes); COPY_LIST_VALS(new->gtktypes, g_strdup);
 331         new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 332         new->id = g_strdup (self->id);
 333         new->args = node_list_copy (self->args);
 334         new->onerror = g_strdup (self->onerror);
 335         new->defreturn = g_strdup (self->defreturn);
 336         new->cbuf = g_strdup (self->cbuf);
 337         new->line_no = self->line_no;
 338         new->ccode_line = self->ccode_line;
 339         new->vararg = self->vararg;
 340         new->unique_id = self->unique_id;
 341         new->bonobo_x_func = self->bonobo_x_func;
 342         return new;
 343 }
 344
 345 static Property *
 346 copy_property (Property * self)
 347 {
 348         Property * new;
 349         g_return_val_if_fail (self != NULL, NULL);
 350         g_return_val_if_fail (self->type == PROPERTY_NODE, NULL);
 351         new = g_new0(Property, 1);
 352         new->type = PROPERTY_NODE;
 353         new->gtktype = g_strdup (self->gtktype);
 354         new->ptype = copy_type (self->ptype);
 355         new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 356         new->name = g_strdup (self->name);
 357         new->nick = g_strdup (self->nick);
 358         new->blurb = g_strdup (self->blurb);
 359         new->minimum = g_strdup (self->minimum);
 360         new->maximum = g_strdup (self->maximum);
 361         new->default_value = g_strdup (self->default_value);
 362         new->extra_gtktype = g_strdup (self->extra_gtktype);
 363         new->link = self->link;
 364         new->export = self->export;
 365         new->get = g_strdup (self->get);
 366         new->get_line = self->get_line;
 367         new->set = g_strdup (self->set);
 368         new->set_line = self->set_line;
 369         new->line_no = self->line_no;
 370         return new;
 371 }
 372
 373 static Type *
 374 copy_type (Type * self)
 375 {
 376         Type * new;
 377         g_return_val_if_fail (self != NULL, NULL);
 378         g_return_val_if_fail (self->type == TYPE_NODE, NULL);
 379         new = g_new0(Type, 1);
 380         new->type = TYPE_NODE;
 381         new->name = g_strdup (self->name);
 382         new->pointer = g_strdup (self->pointer);
 383         new->postfix = g_strdup (self->postfix);
 384         return new;
 385 }
 386
 387 static Variable *
 388 copy_variable (Variable * self)
 389 {
 390         Variable * new;
 391         g_return_val_if_fail (self != NULL, NULL);
 392         g_return_val_if_fail (self->type == VARIABLE_NODE, NULL);
 393         new = g_new0(Variable, 1);
 394         new->type = VARIABLE_NODE;
 395         new->scope = self->scope;
 396         new->vtype = copy_type (self->vtype);
 397         new->id = g_strdup (self->id);
 398         new->line_no = self->line_no;
 399         new->destructor_unref = self->destructor_unref;
 400         new->destructor = g_strdup (self->destructor);
 401         new->destructor_line = self->destructor_line;
 402         new->destructor_simple = self->destructor_simple;
 403         new->initializer = g_strdup (self->initializer);
 404         new->initializer_line = self->initializer_line;
 405         return new;
 406 }
 407
 408 void
 409 free_argument (Argument * self)
 410 {
 411         g_return_if_fail (self != NULL);
 412         g_return_if_fail (self->type == ARGUMENT_NODE);
 413         g_free (self->gtktype);
 414         free_type (self->atype);
 415         g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
 416         g_free (self->name);
 417         g_free (self->get);
 418         g_free (self->set);
 419         g_free (self);
 420 }
 421
 422 void
 423 free_ccode (CCode * self)
 424 {
 425         g_return_if_fail (self != NULL);
 426         g_return_if_fail (self->type == CCODE_NODE);
 427         g_free (self->cbuf);
 428         g_free (self);
 429 }
 430
 431 void
 432 free_check (Check * self)
 433 {
 434         g_return_if_fail (self != NULL);
 435         g_return_if_fail (self->type == CHECK_NODE);
 436         g_free (self->number);
 437         g_free (self);
 438 }
 439
 440 void
 441 free_class (Class * self)
 442 {
 443         g_return_if_fail (self != NULL);
 444         g_return_if_fail (self->type == CLASS_NODE);
 445         g_free (self->otype);
 446         g_free (self->ptype);
 447         g_free (self->bonobo_x_class);
 448         g_free (self->chunk_size);
 449         node_list_free (self->nodes);
 450         g_free (self);
 451 }
 452
 453 void
 454 free_funcarg (FuncArg * self)
 455 {
 456         g_return_if_fail (self != NULL);
 457         g_return_if_fail (self->type == FUNCARG_NODE);
 458         free_type (self->atype);
 459         g_free (self->name);
 460         node_list_free (self->checks);
 461         g_free (self);
 462 }
 463
 464 void
 465 free_method (Method * self)
 466 {
 467         g_return_if_fail (self != NULL);
 468         g_return_if_fail (self->type == METHOD_NODE);
 469         free_type (self->mtype);
 470         g_free (self->otype);
 471         g_list_foreach (self->gtktypes, (GFunc)g_free, NULL); g_list_free (self->gtktypes);
 472         g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
 473         g_free (self->id);
 474         node_list_free (self->args);
 475         g_free (self->onerror);
 476         g_free (self->defreturn);
 477         g_free (self->cbuf);
 478         g_free (self);
 479 }
 480
 481 void
 482 free_property (Property * self)
 483 {
 484         g_return_if_fail (self != NULL);
 485         g_return_if_fail (self->type == PROPERTY_NODE);
 486         g_free (self->gtktype);
 487         free_type (self->ptype);
 488         g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
 489         g_free (self->name);
 490         g_free (self->nick);
 491         g_free (self->blurb);
 492         g_free (self->minimum);
 493         g_free (self->maximum);
 494         g_free (self->default_value);
 495         g_free (self->extra_gtktype);
 496         g_free (self->get);
 497         g_free (self->set);
 498         g_free (self);
 499 }
 500
 501 void
 502 free_type (Type * self)
 503 {
 504         g_return_if_fail (self != NULL);
 505         g_return_if_fail (self->type == TYPE_NODE);
 506         g_free (self->name);
 507         g_free (self->pointer);
 508         g_free (self->postfix);
 509         g_free (self);
 510 }
 511
 512 void
 513 free_variable (Variable * self)
 514 {
 515         g_return_if_fail (self != NULL);
 516         g_return_if_fail (self->type == VARIABLE_NODE);
 517         free_type (self->vtype);
 518         g_free (self->id);
 519         g_free (self->destructor);
 520         g_free (self->initializer);
 521         g_free (self);
 522 }
 523
 524 static void
 525 setv_argument (Argument * self, va_list __ap)
 526 {
 527         int quark;
 528         const char *arg;
 529         ensure_quarks ();
 530         while ((arg = va_arg (__ap, char *)) != NULL) {
 531                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 532                 switch (quark) {
 533                 case QUARK_gtktype: {
 534                         char * gtktype = va_arg (__ap, char *);
 535                         char * __old_value = self->gtktype;
 536                         self->gtktype = g_strdup (gtktype);
 537                         g_free (__old_value);
 538                         break;
 539                 }
 540                 case QUARK_gtktype_STEAL: {
 541                         char * gtktype = va_arg (__ap, char *);
 542                         self->gtktype = gtktype;
 543                         break;
 544                 }
 545                 case QUARK_atype: {
 546                         Type * atype = va_arg (__ap, Type *);
 547                         Type * __old_value = self->atype;
 548                         self->atype = copy_type (atype);
 549                         free_type (__old_value);
 550                         break;
 551                 }
 552                 case QUARK_atype_STEAL: {
 553                         Type * atype = va_arg (__ap, Type *);
 554                         self->atype = atype;
 555                         break;
 556                 }
 557                 case QUARK_flags: {
 558                         GList * flags = va_arg (__ap, GList *);
 559                         GList * __old_value = self->flags;
 560                         self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
 561                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
 562                         break;
 563                 }
 564                 case QUARK_flags_STEAL: {
 565                         GList * flags = va_arg (__ap, GList *);
 566                         self->flags = flags;
 567                         break;
 568                 }
 569                 case QUARK_name: {
 570                         char * name = va_arg (__ap, char *);
 571                         char * __old_value = self->name;
 572                         self->name = g_strdup (name);
 573                         g_free (__old_value);
 574                         break;
 575                 }
 576                 case QUARK_name_STEAL: {
 577                         char * name = va_arg (__ap, char *);
 578                         self->name = name;
 579                         break;
 580                 }
 581                 case QUARK_get: {
 582                         char * get = va_arg (__ap, char *);
 583                         char * __old_value = self->get;
 584                         self->get = g_strdup (get);
 585                         g_free (__old_value);
 586                         break;
 587                 }
 588                 case QUARK_get_STEAL: {
 589                         char * get = va_arg (__ap, char *);
 590                         self->get = get;
 591                         break;
 592                 }
 593                 case QUARK_get_line: {
 594                         int get_line = va_arg (__ap, int);
 595                         self->get_line = get_line;
 596                         break;
 597                 }
 598                 case QUARK_set: {
 599                         char * set = va_arg (__ap, char *);
 600                         char * __old_value = self->set;
 601                         self->set = g_strdup (set);
 602                         g_free (__old_value);
 603                         break;
 604                 }
 605                 case QUARK_set_STEAL: {
 606                         char * set = va_arg (__ap, char *);
 607                         self->set = set;
 608                         break;
 609                 }
 610                 case QUARK_set_line: {
 611                         int set_line = va_arg (__ap, int);
 612                         self->set_line = set_line;
 613                         break;
 614                 }
 615                 case QUARK_line_no: {
 616                         int line_no = va_arg (__ap, int);
 617                         self->line_no = line_no;
 618                         break;
 619                 }
 620                 default:
 621                         g_warning ("Argument named 'Argument::%s' does not exist", arg);
 622                         break;
 623                 }
 624         }
 625 }
 626
 627 static void
 628 setv_ccode (CCode * self, va_list __ap)
 629 {
 630         int quark;
 631         const char *arg;
 632         ensure_quarks ();
 633         while ((arg = va_arg (__ap, char *)) != NULL) {
 634                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 635                 switch (quark) {
 636                 case QUARK_cctype: {
 637                         int cctype = va_arg (__ap, int);
 638                         self->cctype = cctype;
 639                         break;
 640                 }
 641                 case QUARK_cbuf: {
 642                         char * cbuf = va_arg (__ap, char *);
 643                         char * __old_value = self->cbuf;
 644                         self->cbuf = g_strdup (cbuf);
 645                         g_free (__old_value);
 646                         break;
 647                 }
 648                 case QUARK_cbuf_STEAL: {
 649                         char * cbuf = va_arg (__ap, char *);
 650                         self->cbuf = cbuf;
 651                         break;
 652                 }
 653                 case QUARK_line_no: {
 654                         int line_no = va_arg (__ap, int);
 655                         self->line_no = line_no;
 656                         break;
 657                 }
 658                 default:
 659                         g_warning ("Argument named 'CCode::%s' does not exist", arg);
 660                         break;
 661                 }
 662         }
 663 }
 664
 665 static void
 666 setv_check (Check * self, va_list __ap)
 667 {
 668         int quark;
 669         const char *arg;
 670         ensure_quarks ();
 671         while ((arg = va_arg (__ap, char *)) != NULL) {
 672                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 673                 switch (quark) {
 674                 case QUARK_chtype: {
 675                         int chtype = va_arg (__ap, int);
 676                         self->chtype = chtype;
 677                         break;
 678                 }
 679                 case QUARK_number: {
 680                         char * number = va_arg (__ap, char *);
 681                         char * __old_value = self->number;
 682                         self->number = g_strdup (number);
 683                         g_free (__old_value);
 684                         break;
 685                 }
 686                 case QUARK_number_STEAL: {
 687                         char * number = va_arg (__ap, char *);
 688                         self->number = number;
 689                         break;
 690                 }
 691                 default:
 692                         g_warning ("Argument named 'Check::%s' does not exist", arg);
 693                         break;
 694                 }
 695         }
 696 }
 697
 698 static void
 699 setv_class (Class * self, va_list __ap)
 700 {
 701         int quark;
 702         const char *arg;
 703         ensure_quarks ();
 704         while ((arg = va_arg (__ap, char *)) != NULL) {
 705                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 706                 switch (quark) {
 707                 case QUARK_otype: {
 708                         char * otype = va_arg (__ap, char *);
 709                         char * __old_value = self->otype;
 710                         self->otype = g_strdup (otype);
 711                         g_free (__old_value);
 712                         break;
 713                 }
 714                 case QUARK_otype_STEAL: {
 715                         char * otype = va_arg (__ap, char *);
 716                         self->otype = otype;
 717                         break;
 718                 }
 719                 case QUARK_ptype: {
 720                         char * ptype = va_arg (__ap, char *);
 721                         char * __old_value = self->ptype;
 722                         self->ptype = g_strdup (ptype);
 723                         g_free (__old_value);
 724                         break;
 725                 }
 726                 case QUARK_ptype_STEAL: {
 727                         char * ptype = va_arg (__ap, char *);
 728                         self->ptype = ptype;
 729                         break;
 730                 }
 731                 case QUARK_bonobo_x_class: {
 732                         char * bonobo_x_class = va_arg (__ap, char *);
 733                         char * __old_value = self->bonobo_x_class;
 734                         self->bonobo_x_class = g_strdup (bonobo_x_class);
 735                         g_free (__old_value);
 736                         break;
 737                 }
 738                 case QUARK_bonobo_x_class_STEAL: {
 739                         char * bonobo_x_class = va_arg (__ap, char *);
 740                         self->bonobo_x_class = bonobo_x_class;
 741                         break;
 742                 }
 743                 case QUARK_chunk_size: {
 744                         char * chunk_size = va_arg (__ap, char *);
 745                         char * __old_value = self->chunk_size;
 746                         self->chunk_size = g_strdup (chunk_size);
 747                         g_free (__old_value);
 748                         break;
 749                 }
 750                 case QUARK_chunk_size_STEAL: {
 751                         char * chunk_size = va_arg (__ap, char *);
 752                         self->chunk_size = chunk_size;
 753                         break;
 754                 }
 755                 case QUARK_nodes: {
 756                         GList * nodes = va_arg (__ap, GList *);
 757                         GList * __old_value = self->nodes;
 758                         self->nodes = node_list_copy (nodes);
 759                         node_list_free (__old_value);
 760                         break;
 761                 }
 762                 case QUARK_nodes_STEAL: {
 763                         GList * nodes = va_arg (__ap, GList *);
 764                         self->nodes = nodes;
 765                         break;
 766                 }
 767                 default:
 768                         g_warning ("Argument named 'Class::%s' does not exist", arg);
 769                         break;
 770                 }
 771         }
 772 }
 773
 774 static void
 775 setv_funcarg (FuncArg * self, va_list __ap)
 776 {
 777         int quark;
 778         const char *arg;
 779         ensure_quarks ();
 780         while ((arg = va_arg (__ap, char *)) != NULL) {
 781                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 782                 switch (quark) {
 783                 case QUARK_atype: {
 784                         Type * atype = va_arg (__ap, Type *);
 785                         Type * __old_value = self->atype;
 786                         self->atype = copy_type (atype);
 787                         free_type (__old_value);
 788                         break;
 789                 }
 790                 case QUARK_atype_STEAL: {
 791                         Type * atype = va_arg (__ap, Type *);
 792                         self->atype = atype;
 793                         break;
 794                 }
 795                 case QUARK_name: {
 796                         char * name = va_arg (__ap, char *);
 797                         char * __old_value = self->name;
 798                         self->name = g_strdup (name);
 799                         g_free (__old_value);
 800                         break;
 801                 }
 802                 case QUARK_name_STEAL: {
 803                         char * name = va_arg (__ap, char *);
 804                         self->name = name;
 805                         break;
 806                 }
 807                 case QUARK_checks: {
 808                         GList * checks = va_arg (__ap, GList *);
 809                         GList * __old_value = self->checks;
 810                         self->checks = node_list_copy (checks);
 811                         node_list_free (__old_value);
 812                         break;
 813                 }
 814                 case QUARK_checks_STEAL: {
 815                         GList * checks = va_arg (__ap, GList *);
 816                         self->checks = checks;
 817                         break;
 818                 }
 819                 default:
 820                         g_warning ("Argument named 'FuncArg::%s' does not exist", arg);
 821                         break;
 822                 }
 823         }
 824 }
 825
 826 static void
 827 setv_method (Method * self, va_list __ap)
 828 {
 829         int quark;
 830         const char *arg;
 831         ensure_quarks ();
 832         while ((arg = va_arg (__ap, char *)) != NULL) {
 833                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 834                 switch (quark) {
 835                 case QUARK_scope: {
 836                         int scope = va_arg (__ap, int);
 837                         self->scope = scope;
 838                         break;
 839                 }
 840                 case QUARK_method: {
 841                         int method = va_arg (__ap, int);
 842                         self->method = method;
 843                         break;
 844                 }
 845                 case QUARK_mtype: {
 846                         Type * mtype = va_arg (__ap, Type *);
 847                         Type * __old_value = self->mtype;
 848                         self->mtype = copy_type (mtype);
 849                         free_type (__old_value);
 850                         break;
 851                 }
 852                 case QUARK_mtype_STEAL: {
 853                         Type * mtype = va_arg (__ap, Type *);
 854                         self->mtype = mtype;
 855                         break;
 856                 }
 857                 case QUARK_otype: {
 858                         char * otype = va_arg (__ap, char *);
 859                         char * __old_value = self->otype;
 860                         self->otype = g_strdup (otype);
 861                         g_free (__old_value);
 862                         break;
 863                 }
 864                 case QUARK_otype_STEAL: {
 865                         char * otype = va_arg (__ap, char *);
 866                         self->otype = otype;
 867                         break;
 868                 }
 869                 case QUARK_gtktypes: {
 870                         GList * gtktypes = va_arg (__ap, GList *);
 871                         GList * __old_value = self->gtktypes;
 872                         self->gtktypes = g_list_copy (gtktypes); COPY_LIST_VALS(self->gtktypes, g_strdup);
 873                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
 874                         break;
 875                 }
 876                 case QUARK_gtktypes_STEAL: {
 877                         GList * gtktypes = va_arg (__ap, GList *);
 878                         self->gtktypes = gtktypes;
 879                         break;
 880                 }
 881                 case QUARK_flags: {
 882                         GList * flags = va_arg (__ap, GList *);
 883                         GList * __old_value = self->flags;
 884                         self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
 885                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
 886                         break;
 887                 }
 888                 case QUARK_flags_STEAL: {
 889                         GList * flags = va_arg (__ap, GList *);
 890                         self->flags = flags;
 891                         break;
 892                 }
 893                 case QUARK_id: {
 894                         char * id = va_arg (__ap, char *);
 895                         char * __old_value = self->id;
 896                         self->id = g_strdup (id);
 897                         g_free (__old_value);
 898                         break;
 899                 }
 900                 case QUARK_id_STEAL: {
 901                         char * id = va_arg (__ap, char *);
 902                         self->id = id;
 903                         break;
 904                 }
 905                 case QUARK_args: {
 906                         GList * args = va_arg (__ap, GList *);
 907                         GList * __old_value = self->args;
 908                         self->args = node_list_copy (args);
 909                         node_list_free (__old_value);
 910                         break;
 911                 }
 912                 case QUARK_args_STEAL: {
 913                         GList * args = va_arg (__ap, GList *);
 914                         self->args = args;
 915                         break;
 916                 }
 917                 case QUARK_onerror: {
 918                         char * onerror = va_arg (__ap, char *);
 919                         char * __old_value = self->onerror;
 920                         self->onerror = g_strdup (onerror);
 921                         g_free (__old_value);
 922                         break;
 923                 }
 924                 case QUARK_onerror_STEAL: {
 925                         char * onerror = va_arg (__ap, char *);
 926                         self->onerror = onerror;
 927                         break;
 928                 }
 929                 case QUARK_defreturn: {
 930                         char * defreturn = va_arg (__ap, char *);
 931                         char * __old_value = self->defreturn;
 932                         self->defreturn = g_strdup (defreturn);
 933                         g_free (__old_value);
 934                         break;
 935                 }
 936                 case QUARK_defreturn_STEAL: {
 937                         char * defreturn = va_arg (__ap, char *);
 938                         self->defreturn = defreturn;
 939                         break;
 940                 }
 941                 case QUARK_cbuf: {
 942                         char * cbuf = va_arg (__ap, char *);
 943                         char * __old_value = self->cbuf;
 944                         self->cbuf = g_strdup (cbuf);
 945                         g_free (__old_value);
 946                         break;
 947                 }
 948                 case QUARK_cbuf_STEAL: {
 949                         char * cbuf = va_arg (__ap, char *);
 950                         self->cbuf = cbuf;
 951                         break;
 952                 }
 953                 case QUARK_line_no: {
 954                         int line_no = va_arg (__ap, int);
 955                         self->line_no = line_no;
 956                         break;
 957                 }
 958                 case QUARK_ccode_line: {
 959                         int ccode_line = va_arg (__ap, int);
 960                         self->ccode_line = ccode_line;
 961                         break;
 962                 }
 963                 case QUARK_vararg: {
 964                         gboolean vararg = va_arg (__ap, gboolean);
 965                         self->vararg = vararg;
 966                         break;
 967                 }
 968                 case QUARK_unique_id: {
 969                         int unique_id = va_arg (__ap, int);
 970                         self->unique_id = unique_id;
 971                         break;
 972                 }
 973                 case QUARK_bonobo_x_func: {
 974                         gboolean bonobo_x_func = va_arg (__ap, gboolean);
 975                         self->bonobo_x_func = bonobo_x_func;
 976                         break;
 977                 }
 978                 default:
 979                         g_warning ("Argument named 'Method::%s' does not exist", arg);
 980                         break;
 981                 }
 982         }
 983 }
 984
 985 static void
 986 setv_property (Property * self, va_list __ap)
 987 {
 988         int quark;
 989         const char *arg;
 990         ensure_quarks ();
 991         while ((arg = va_arg (__ap, char *)) != NULL) {
 992                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 993                 switch (quark) {
 994                 case QUARK_gtktype: {
 995                         char * gtktype = va_arg (__ap, char *);
 996                         char * __old_value = self->gtktype;
 997                         self->gtktype = g_strdup (gtktype);
 998                         g_free (__old_value);
 999                         break;
1000                 }
1001                 case QUARK_gtktype_STEAL: {
1002                         char * gtktype = va_arg (__ap, char *);
1003                         self->gtktype = gtktype;
1004                         break;
1005                 }
1006                 case QUARK_ptype: {
1007                         Type * ptype = va_arg (__ap, Type *);
1008                         Type * __old_value = self->ptype;
1009                         self->ptype = copy_type (ptype);
1010                         free_type (__old_value);
1011                         break;
1012                 }
1013                 case QUARK_ptype_STEAL: {
1014                         Type * ptype = va_arg (__ap, Type *);
1015                         self->ptype = ptype;
1016                         break;
1017                 }
1018                 case QUARK_flags: {
1019                         GList * flags = va_arg (__ap, GList *);
1020                         GList * __old_value = self->flags;
1021                         self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
1022                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
1023                         break;
1024                 }
1025                 case QUARK_flags_STEAL: {
1026                         GList * flags = va_arg (__ap, GList *);
1027                         self->flags = flags;
1028                         break;
1029                 }
1030                 case QUARK_name: {
1031                         char * name = va_arg (__ap, char *);
1032                         char * __old_value = self->name;
1033                         self->name = g_strdup (name);
1034                         g_free (__old_value);
1035                         break;
1036                 }
1037                 case QUARK_name_STEAL: {
1038                         char * name = va_arg (__ap, char *);
1039                         self->name = name;
1040                         break;
1041                 }
1042                 case QUARK_nick: {
1043                         char * nick = va_arg (__ap, char *);
1044                         char * __old_value = self->nick;
1045                         self->nick = g_strdup (nick);
1046                         g_free (__old_value);
1047                         break;
1048                 }
1049                 case QUARK_nick_STEAL: {
1050                         char * nick = va_arg (__ap, char *);
1051                         self->nick = nick;
1052                         break;
1053                 }
1054                 case QUARK_blurb: {
1055                         char * blurb = va_arg (__ap, char *);
1056                         char * __old_value = self->blurb;
1057                         self->blurb = g_strdup (blurb);
1058                         g_free (__old_value);
1059                         break;
1060                 }
1061                 case QUARK_blurb_STEAL: {
1062                         char * blurb = va_arg (__ap, char *);
1063                         self->blurb = blurb;
1064                         break;
1065                 }
1066                 case QUARK_minimum: {
1067                         char * minimum = va_arg (__ap, char *);
1068                         char * __old_value = self->minimum;
1069                         self->minimum = g_strdup (minimum);
1070                         g_free (__old_value);
1071                         break;
1072                 }
1073                 case QUARK_minimum_STEAL: {
1074                         char * minimum = va_arg (__ap, char *);
1075                         self->minimum = minimum;
1076                         break;
1077                 }
1078                 case QUARK_maximum: {
1079                         char * maximum = va_arg (__ap, char *);
1080                         char * __old_value = self->maximum;
1081                         self->maximum = g_strdup (maximum);
1082                         g_free (__old_value);
1083                         break;
1084                 }
1085                 case QUARK_maximum_STEAL: {
1086                         char * maximum = va_arg (__ap, char *);
1087                         self->maximum = maximum;
1088                         break;
1089                 }
1090                 case QUARK_default_value: {
1091                         char * default_value = va_arg (__ap, char *);
1092                         char * __old_value = self->default_value;
1093                         self->default_value = g_strdup (default_value);
1094                         g_free (__old_value);
1095                         break;
1096                 }
1097                 case QUARK_default_value_STEAL: {
1098                         char * default_value = va_arg (__ap, char *);
1099                         self->default_value = default_value;
1100                         break;
1101                 }
1102                 case QUARK_extra_gtktype: {
1103                         char * extra_gtktype = va_arg (__ap, char *);
1104                         char * __old_value = self->extra_gtktype;
1105                         self->extra_gtktype = g_strdup (extra_gtktype);
1106                         g_free (__old_value);
1107                         break;
1108                 }
1109                 case QUARK_extra_gtktype_STEAL: {
1110                         char * extra_gtktype = va_arg (__ap, char *);
1111                         self->extra_gtktype = extra_gtktype;
1112                         break;
1113                 }
1114                 case QUARK_link: {
1115                         gboolean link = va_arg (__ap, gboolean);
1116                         self->link = link;
1117                         break;
1118                 }
1119                 case QUARK_export: {
1120                         gboolean export = va_arg (__ap, gboolean);
1121                         self->export = export;
1122                         break;
1123                 }
1124                 case QUARK_get: {
1125                         char * get = va_arg (__ap, char *);
1126                         char * __old_value = self->get;
1127                         self->get = g_strdup (get);
1128                         g_free (__old_value);
1129                         break;
1130                 }
1131                 case QUARK_get_STEAL: {
1132                         char * get = va_arg (__ap, char *);
1133                         self->get = get;
1134                         break;
1135                 }
1136                 case QUARK_get_line: {
1137                         int get_line = va_arg (__ap, int);
1138                         self->get_line = get_line;
1139                         break;
1140                 }
1141                 case QUARK_set: {
1142                         char * set = va_arg (__ap, char *);
1143                         char * __old_value = self->set;
1144                         self->set = g_strdup (set);
1145                         g_free (__old_value);
1146                         break;
1147                 }
1148                 case QUARK_set_STEAL: {
1149                         char * set = va_arg (__ap, char *);
1150                         self->set = set;
1151                         break;
1152                 }
1153                 case QUARK_set_line: {
1154                         int set_line = va_arg (__ap, int);
1155                         self->set_line = set_line;
1156                         break;
1157                 }
1158                 case QUARK_line_no: {
1159                         int line_no = va_arg (__ap, int);
1160                         self->line_no = line_no;
1161                         break;
1162                 }
1163                 default:
1164                         g_warning ("Argument named 'Property::%s' does not exist", arg);
1165                         break;
1166                 }
1167         }
1168 }
1169
1170 static void
1171 setv_type (Type * self, va_list __ap)
1172 {
1173         int quark;
1174         const char *arg;
1175         ensure_quarks ();
1176         while ((arg = va_arg (__ap, char *)) != NULL) {
1177                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1178                 switch (quark) {
1179                 case QUARK_name: {
1180                         char * name = va_arg (__ap, char *);
1181                         char * __old_value = self->name;
1182                         self->name = g_strdup (name);
1183                         g_free (__old_value);
1184                         break;
1185                 }
1186                 case QUARK_name_STEAL: {
1187                         char * name = va_arg (__ap, char *);
1188                         self->name = name;
1189                         break;
1190                 }
1191                 case QUARK_pointer: {
1192                         char * pointer = va_arg (__ap, char *);
1193                         char * __old_value = self->pointer;
1194                         self->pointer = g_strdup (pointer);
1195                         g_free (__old_value);
1196                         break;
1197                 }
1198                 case QUARK_pointer_STEAL: {
1199                         char * pointer = va_arg (__ap, char *);
1200                         self->pointer = pointer;
1201                         break;
1202                 }
1203                 case QUARK_postfix: {
1204                         char * postfix = va_arg (__ap, char *);
1205                         char * __old_value = self->postfix;
1206                         self->postfix = g_strdup (postfix);
1207                         g_free (__old_value);
1208                         break;
1209                 }
1210                 case QUARK_postfix_STEAL: {
1211                         char * postfix = va_arg (__ap, char *);
1212                         self->postfix = postfix;
1213                         break;
1214                 }
1215                 default:
1216                         g_warning ("Argument named 'Type::%s' does not exist", arg);
1217                         break;
1218                 }
1219         }
1220 }
1221
1222 static void
1223 setv_variable (Variable * self, va_list __ap)
1224 {
1225         int quark;
1226         const char *arg;
1227         ensure_quarks ();
1228         while ((arg = va_arg (__ap, char *)) != NULL) {
1229                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1230                 switch (quark) {
1231                 case QUARK_scope: {
1232                         int scope = va_arg (__ap, int);
1233                         self->scope = scope;
1234                         break;
1235                 }
1236                 case QUARK_vtype: {
1237                         Type * vtype = va_arg (__ap, Type *);
1238                         Type * __old_value = self->vtype;
1239                         self->vtype = copy_type (vtype);
1240                         free_type (__old_value);
1241                         break;
1242                 }
1243                 case QUARK_vtype_STEAL: {
1244                         Type * vtype = va_arg (__ap, Type *);
1245                         self->vtype = vtype;
1246                         break;
1247                 }
1248                 case QUARK_id: {
1249                         char * id = va_arg (__ap, char *);
1250                         char * __old_value = self->id;
1251                         self->id = g_strdup (id);
1252                         g_free (__old_value);
1253                         break;
1254                 }
1255                 case QUARK_id_STEAL: {
1256                         char * id = va_arg (__ap, char *);
1257                         self->id = id;
1258                         break;
1259                 }
1260                 case QUARK_line_no: {
1261                         int line_no = va_arg (__ap, int);
1262                         self->line_no = line_no;
1263                         break;
1264                 }
1265                 case QUARK_destructor_unref: {
1266                         gboolean destructor_unref = va_arg (__ap, gboolean);
1267                         self->destructor_unref = destructor_unref;
1268                         break;
1269                 }
1270                 case QUARK_destructor: {
1271                         char * destructor = va_arg (__ap, char *);
1272                         char * __old_value = self->destructor;
1273                         self->destructor = g_strdup (destructor);
1274                         g_free (__old_value);
1275                         break;
1276                 }
1277                 case QUARK_destructor_STEAL: {
1278                         char * destructor = va_arg (__ap, char *);
1279                         self->destructor = destructor;
1280                         break;
1281                 }
1282                 case QUARK_destructor_line: {
1283                         int destructor_line = va_arg (__ap, int);
1284                         self->destructor_line = destructor_line;
1285                         break;
1286                 }
1287                 case QUARK_destructor_simple: {
1288                         gboolean destructor_simple = va_arg (__ap, gboolean);
1289                         self->destructor_simple = destructor_simple;
1290                         break;
1291                 }
1292                 case QUARK_initializer: {
1293                         char * initializer = va_arg (__ap, char *);
1294                         char * __old_value = self->initializer;
1295                         self->initializer = g_strdup (initializer);
1296                         g_free (__old_value);
1297                         break;
1298                 }
1299                 case QUARK_initializer_STEAL: {
1300                         char * initializer = va_arg (__ap, char *);
1301                         self->initializer = initializer;
1302                         break;
1303                 }
1304                 case QUARK_initializer_line: {
1305                         int initializer_line = va_arg (__ap, int);
1306                         self->initializer_line = initializer_line;
1307                         break;
1308                 }
1309                 default:
1310                         g_warning ("Argument named 'Variable::%s' does not exist", arg);
1311                         break;
1312                 }
1313         }
1314 }
1315
1316 Node *
1317 node_copy (Node *node)
1318 {
1319         g_return_val_if_fail (node != NULL, NULL);
1320         g_return_val_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE, NULL);
1321         switch (node->type) {
1322         case ARGUMENT_NODE: return (Node *)copy_argument ((Argument *)node);
1323         case CCODE_NODE: return (Node *)copy_ccode ((CCode *)node);
1324         case CHECK_NODE: return (Node *)copy_check ((Check *)node);
1325         case CLASS_NODE: return (Node *)copy_class ((Class *)node);
1326         case FUNCARG_NODE: return (Node *)copy_funcarg ((FuncArg *)node);
1327         case METHOD_NODE: return (Node *)copy_method ((Method *)node);
1328         case PROPERTY_NODE: return (Node *)copy_property ((Property *)node);
1329         case TYPE_NODE: return (Node *)copy_type ((Type *)node);
1330         case VARIABLE_NODE: return (Node *)copy_variable ((Variable *)node);
1331         default: return NULL;
1332         }
1333 }
1334
1335 static void
1336 node_setv (Node *node, va_list __ap)
1337 {
1338         g_return_if_fail (node != NULL);
1339         g_return_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE);
1340         switch (node->type) {
1341         case ARGUMENT_NODE: setv_argument ((Argument *)node, __ap); break;
1342         case CCODE_NODE: setv_ccode ((CCode *)node, __ap); break;
1343         case CHECK_NODE: setv_check ((Check *)node, __ap); break;
1344         case CLASS_NODE: setv_class ((Class *)node, __ap); break;
1345         case FUNCARG_NODE: setv_funcarg ((FuncArg *)node, __ap); break;
1346         case METHOD_NODE: setv_method ((Method *)node, __ap); break;
1347         case PROPERTY_NODE: setv_property ((Property *)node, __ap); break;
1348         case TYPE_NODE: setv_type ((Type *)node, __ap); break;
1349         case VARIABLE_NODE: setv_variable ((Variable *)node, __ap); break;
1350         default: break;
1351         }
1352 }
1353
1354 void
1355 node_set (Node *node, ...)
1356 {
1357         va_list __ap;
1358         va_start (__ap, node);
1359         node_setv (node, __ap);
1360         va_end (__ap);
1361 }
1362
1363 Node *
1364 node_new (NodeType type, ...)
1365 {
1366         va_list __ap;
1367         Node *node = NULL;
1368         va_start (__ap, type);
1369         g_return_val_if_fail (type >= 0 && type < LAST_NODE_TYPE, NULL);
1370         switch (type) {
1371         case ARGUMENT_NODE:
1372                 node = (Node *)g_new0 (Argument, 1);
1373                 node->type = type;
1374                 setv_argument ((Argument *)node, __ap);
1375                 break;
1376         case CCODE_NODE:
1377                 node = (Node *)g_new0 (CCode, 1);
1378                 node->type = type;
1379                 setv_ccode ((CCode *)node, __ap);
1380                 break;
1381         case CHECK_NODE:
1382                 node = (Node *)g_new0 (Check, 1);
1383                 node->type = type;
1384                 setv_check ((Check *)node, __ap);
1385                 break;
1386         case CLASS_NODE:
1387                 node = (Node *)g_new0 (Class, 1);
1388                 node->type = type;
1389                 setv_class ((Class *)node, __ap);
1390                 break;
1391         case FUNCARG_NODE:
1392                 node = (Node *)g_new0 (FuncArg, 1);
1393                 node->type = type;
1394                 setv_funcarg ((FuncArg *)node, __ap);
1395                 break;
1396         case METHOD_NODE:
1397                 node = (Node *)g_new0 (Method, 1);
1398                 node->type = type;
1399                 setv_method ((Method *)node, __ap);
1400                 break;
1401         case PROPERTY_NODE:
1402                 node = (Node *)g_new0 (Property, 1);
1403                 node->type = type;
1404                 setv_property ((Property *)node, __ap);
1405                 break;
1406         case TYPE_NODE:
1407                 node = (Node *)g_new0 (Type, 1);
1408                 node->type = type;
1409                 setv_type ((Type *)node, __ap);
1410                 break;
1411         case VARIABLE_NODE:
1412                 node = (Node *)g_new0 (Variable, 1);
1413                 node->type = type;
1414                 setv_variable ((Variable *)node, __ap);
1415                 break;
1416         default: break;
1417         }
1418         va_end (__ap);
1419         return node;
1420 }
1421
1422 void
1423 node_free (Node *node)
1424 {
1425         g_return_if_fail (node != NULL);
1426         g_return_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE);
1427         switch (node->type) {
1428         case ARGUMENT_NODE: free_argument ((Argument *)node); return;
1429         case CCODE_NODE: free_ccode ((CCode *)node); return;
1430         case CHECK_NODE: free_check ((Check *)node); return;
1431         case CLASS_NODE: free_class ((Class *)node); return;
1432         case FUNCARG_NODE: free_funcarg ((FuncArg *)node); return;
1433         case METHOD_NODE: free_method ((Method *)node); return;
1434         case PROPERTY_NODE: free_property ((Property *)node); return;
1435         case TYPE_NODE: free_type ((Type *)node); return;
1436         case VARIABLE_NODE: free_variable ((Variable *)node); return;
1437         default: return;
1438         }
1439 }
1440
1441 GList *
1442 node_list_copy (GList *nodes)
1443 {
1444         GList *li;
1445         nodes = g_list_copy (nodes);
1446         for (li = nodes; li != NULL; li = li->next) {
1447                 li->data = node_copy (li->data);
1448         }
1449         return nodes;
1450 }
1451
1452 void
1453 node_list_free (GList *nodes)
1454 {
1455         GList *li;
1456         for (li = nodes; li != NULL; li = li->next) {
1457                 node_free (li->data);
1458         }
1459         g_list_free (nodes);
1460 }
1461