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 EnumDef *
  19 copy_enumdef (EnumDef * self);
  20 static EnumValue *
  21 copy_enumvalue (EnumValue * self);
  22 static Error *
  23 copy_error (Error * self);
  24 static Flags *
  25 copy_flags (Flags * self);
  26 static FuncArg *
  27 copy_funcarg (FuncArg * self);
  28 static Method *
  29 copy_method (Method * self);
  30 static Property *
  31 copy_property (Property * self);
  32 static Type *
  33 copy_type (Type * self);
  34 static Variable *
  35 copy_variable (Variable * self);
  36
  37 void
  38 free_argument (Argument * self);
  39 void
  40 free_ccode (CCode * self);
  41 void
  42 free_check (Check * self);
  43 void
  44 free_class (Class * self);
  45 void
  46 free_enumdef (EnumDef * self);
  47 void
  48 free_enumvalue (EnumValue * self);
  49 void
  50 free_error (Error * self);
  51 void
  52 free_flags (Flags * self);
  53 void
  54 free_funcarg (FuncArg * self);
  55 void
  56 free_method (Method * self);
  57 void
  58 free_property (Property * self);
  59 void
  60 free_type (Type * self);
  61 void
  62 free_variable (Variable * self);
  63
  64 static void
  65 setv_argument (Argument * self, va_list __ap);
  66 static void
  67 setv_ccode (CCode * self, va_list __ap);
  68 static void
  69 setv_check (Check * self, va_list __ap);
  70 static void
  71 setv_class (Class * self, va_list __ap);
  72 static void
  73 setv_enumdef (EnumDef * self, va_list __ap);
  74 static void
  75 setv_enumvalue (EnumValue * self, va_list __ap);
  76 static void
  77 setv_error (Error * self, va_list __ap);
  78 static void
  79 setv_flags (Flags * self, va_list __ap);
  80 static void
  81 setv_funcarg (FuncArg * self, va_list __ap);
  82 static void
  83 setv_method (Method * self, va_list __ap);
  84 static void
  85 setv_property (Property * self, va_list __ap);
  86 static void
  87 setv_type (Type * self, va_list __ap);
  88 static void
  89 setv_variable (Variable * self, va_list __ap);
  90
  91 static gboolean quarks_set_up = FALSE;
  92 static GHashTable *quark_ht;
  93 enum {
  94         QUARK_0,
  95         QUARK_otype,
  96         QUARK_otype_STEAL,
  97         QUARK_ptype,
  98         QUARK_ptype_STEAL,
  99         QUARK_bonobo_object_class,
 100         QUARK_bonobo_object_class_STEAL,
 101         QUARK_glade_xml,
 102         QUARK_chunk_size,
 103         QUARK_chunk_size_STEAL,
 104         QUARK_interfaces,
 105         QUARK_interfaces_STEAL,
 106         QUARK_nodes,
 107         QUARK_nodes_STEAL,
 108         QUARK_abstract,
 109         QUARK_name,
 110         QUARK_name_STEAL,
 111         QUARK_pointer,
 112         QUARK_pointer_STEAL,
 113         QUARK_postfix,
 114         QUARK_postfix_STEAL,
 115         QUARK_cctype,
 116         QUARK_cbuf,
 117         QUARK_cbuf_STEAL,
 118         QUARK_line_no,
 119         QUARK_chtype,
 120         QUARK_number,
 121         QUARK_number_STEAL,
 122         QUARK_atype,
 123         QUARK_atype_STEAL,
 124         QUARK_checks,
 125         QUARK_checks_STEAL,
 126         QUARK_gtktype,
 127         QUARK_gtktype_STEAL,
 128         QUARK_flags,
 129         QUARK_flags_STEAL,
 130         QUARK_get,
 131         QUARK_get_STEAL,
 132         QUARK_get_line,
 133         QUARK_set,
 134         QUARK_set_STEAL,
 135         QUARK_set_line,
 136         QUARK_canonical_name,
 137         QUARK_canonical_name_STEAL,
 138         QUARK_nick,
 139         QUARK_nick_STEAL,
 140         QUARK_blurb,
 141         QUARK_blurb_STEAL,
 142         QUARK_minimum,
 143         QUARK_minimum_STEAL,
 144         QUARK_maximum,
 145         QUARK_maximum_STEAL,
 146         QUARK_default_value,
 147         QUARK_default_value_STEAL,
 148         QUARK_extra_gtktype,
 149         QUARK_extra_gtktype_STEAL,
 150         QUARK_override,
 151         QUARK_link,
 152         QUARK_export,
 153         QUARK_scope,
 154         QUARK_method,
 155         QUARK_mtype,
 156         QUARK_mtype_STEAL,
 157         QUARK_gtktypes,
 158         QUARK_gtktypes_STEAL,
 159         QUARK_signal_name,
 160         QUARK_signal_name_STEAL,
 161         QUARK_id,
 162         QUARK_id_STEAL,
 163         QUARK_args,
 164         QUARK_args_STEAL,
 165         QUARK_funcattrs,
 166         QUARK_funcattrs_STEAL,
 167         QUARK_onerror,
 168         QUARK_onerror_STEAL,
 169         QUARK_defreturn,
 170         QUARK_defreturn_STEAL,
 171         QUARK_ccode_line,
 172         QUARK_vararg,
 173         QUARK_unique_id,
 174         QUARK_bonobo_object_func,
 175         QUARK_interface,
 176         QUARK_interface_STEAL,
 177         QUARK_vtype,
 178         QUARK_vtype_STEAL,
 179         QUARK_glade_widget,
 180         QUARK_destructor_unref,
 181         QUARK_destructor,
 182         QUARK_destructor_STEAL,
 183         QUARK_destructor_line,
 184         QUARK_destructor_simple,
 185         QUARK_initializer,
 186         QUARK_initializer_STEAL,
 187         QUARK_initializer_line,
 188         QUARK_initializer_simple,
 189         QUARK_etype,
 190         QUARK_etype_STEAL,
 191         QUARK_prefix,
 192         QUARK_prefix_STEAL,
 193         QUARK_values,
 194         QUARK_values_STEAL,
 195         QUARK_value,
 196         QUARK_value_STEAL,
 197         QUARK_ftype,
 198         QUARK_ftype_STEAL,
 199         QUARK_LAST
 200 };
 201
 202 static void
 203 ensure_quarks (void)
 204 {
 205         if (quarks_set_up)
 206                 return;
 207         quark_ht = g_hash_table_new (g_str_hash, g_str_equal);
 208         quarks_set_up = TRUE;
 209         g_hash_table_insert (quark_ht, "otype", GINT_TO_POINTER (QUARK_otype));
 210         g_hash_table_insert (quark_ht, "otype:steal", GINT_TO_POINTER (QUARK_otype_STEAL));
 211         g_hash_table_insert (quark_ht, "ptype", GINT_TO_POINTER (QUARK_ptype));
 212         g_hash_table_insert (quark_ht, "ptype:steal", GINT_TO_POINTER (QUARK_ptype_STEAL));
 213         g_hash_table_insert (quark_ht, "bonobo_object_class", GINT_TO_POINTER (QUARK_bonobo_object_class));
 214         g_hash_table_insert (quark_ht, "bonobo_object_class:steal", GINT_TO_POINTER (QUARK_bonobo_object_class_STEAL));
 215         g_hash_table_insert (quark_ht, "glade_xml", GINT_TO_POINTER (QUARK_glade_xml));
 216         g_hash_table_insert (quark_ht, "chunk_size", GINT_TO_POINTER (QUARK_chunk_size));
 217         g_hash_table_insert (quark_ht, "chunk_size:steal", GINT_TO_POINTER (QUARK_chunk_size_STEAL));
 218         g_hash_table_insert (quark_ht, "interfaces", GINT_TO_POINTER (QUARK_interfaces));
 219         g_hash_table_insert (quark_ht, "interfaces:steal", GINT_TO_POINTER (QUARK_interfaces_STEAL));
 220         g_hash_table_insert (quark_ht, "nodes", GINT_TO_POINTER (QUARK_nodes));
 221         g_hash_table_insert (quark_ht, "nodes:steal", GINT_TO_POINTER (QUARK_nodes_STEAL));
 222         g_hash_table_insert (quark_ht, "abstract", GINT_TO_POINTER (QUARK_abstract));
 223         g_hash_table_insert (quark_ht, "name", GINT_TO_POINTER (QUARK_name));
 224         g_hash_table_insert (quark_ht, "name:steal", GINT_TO_POINTER (QUARK_name_STEAL));
 225         g_hash_table_insert (quark_ht, "pointer", GINT_TO_POINTER (QUARK_pointer));
 226         g_hash_table_insert (quark_ht, "pointer:steal", GINT_TO_POINTER (QUARK_pointer_STEAL));
 227         g_hash_table_insert (quark_ht, "postfix", GINT_TO_POINTER (QUARK_postfix));
 228         g_hash_table_insert (quark_ht, "postfix:steal", GINT_TO_POINTER (QUARK_postfix_STEAL));
 229         g_hash_table_insert (quark_ht, "cctype", GINT_TO_POINTER (QUARK_cctype));
 230         g_hash_table_insert (quark_ht, "cbuf", GINT_TO_POINTER (QUARK_cbuf));
 231         g_hash_table_insert (quark_ht, "cbuf:steal", GINT_TO_POINTER (QUARK_cbuf_STEAL));
 232         g_hash_table_insert (quark_ht, "line_no", GINT_TO_POINTER (QUARK_line_no));
 233         g_hash_table_insert (quark_ht, "chtype", GINT_TO_POINTER (QUARK_chtype));
 234         g_hash_table_insert (quark_ht, "number", GINT_TO_POINTER (QUARK_number));
 235         g_hash_table_insert (quark_ht, "number:steal", GINT_TO_POINTER (QUARK_number_STEAL));
 236         g_hash_table_insert (quark_ht, "atype", GINT_TO_POINTER (QUARK_atype));
 237         g_hash_table_insert (quark_ht, "atype:steal", GINT_TO_POINTER (QUARK_atype_STEAL));
 238         g_hash_table_insert (quark_ht, "checks", GINT_TO_POINTER (QUARK_checks));
 239         g_hash_table_insert (quark_ht, "checks:steal", GINT_TO_POINTER (QUARK_checks_STEAL));
 240         g_hash_table_insert (quark_ht, "gtktype", GINT_TO_POINTER (QUARK_gtktype));
 241         g_hash_table_insert (quark_ht, "gtktype:steal", GINT_TO_POINTER (QUARK_gtktype_STEAL));
 242         g_hash_table_insert (quark_ht, "flags", GINT_TO_POINTER (QUARK_flags));
 243         g_hash_table_insert (quark_ht, "flags:steal", GINT_TO_POINTER (QUARK_flags_STEAL));
 244         g_hash_table_insert (quark_ht, "get", GINT_TO_POINTER (QUARK_get));
 245         g_hash_table_insert (quark_ht, "get:steal", GINT_TO_POINTER (QUARK_get_STEAL));
 246         g_hash_table_insert (quark_ht, "get_line", GINT_TO_POINTER (QUARK_get_line));
 247         g_hash_table_insert (quark_ht, "set", GINT_TO_POINTER (QUARK_set));
 248         g_hash_table_insert (quark_ht, "set:steal", GINT_TO_POINTER (QUARK_set_STEAL));
 249         g_hash_table_insert (quark_ht, "set_line", GINT_TO_POINTER (QUARK_set_line));
 250         g_hash_table_insert (quark_ht, "canonical_name", GINT_TO_POINTER (QUARK_canonical_name));
 251         g_hash_table_insert (quark_ht, "canonical_name:steal", GINT_TO_POINTER (QUARK_canonical_name_STEAL));
 252         g_hash_table_insert (quark_ht, "nick", GINT_TO_POINTER (QUARK_nick));
 253         g_hash_table_insert (quark_ht, "nick:steal", GINT_TO_POINTER (QUARK_nick_STEAL));
 254         g_hash_table_insert (quark_ht, "blurb", GINT_TO_POINTER (QUARK_blurb));
 255         g_hash_table_insert (quark_ht, "blurb:steal", GINT_TO_POINTER (QUARK_blurb_STEAL));
 256         g_hash_table_insert (quark_ht, "minimum", GINT_TO_POINTER (QUARK_minimum));
 257         g_hash_table_insert (quark_ht, "minimum:steal", GINT_TO_POINTER (QUARK_minimum_STEAL));
 258         g_hash_table_insert (quark_ht, "maximum", GINT_TO_POINTER (QUARK_maximum));
 259         g_hash_table_insert (quark_ht, "maximum:steal", GINT_TO_POINTER (QUARK_maximum_STEAL));
 260         g_hash_table_insert (quark_ht, "default_value", GINT_TO_POINTER (QUARK_default_value));
 261         g_hash_table_insert (quark_ht, "default_value:steal", GINT_TO_POINTER (QUARK_default_value_STEAL));
 262         g_hash_table_insert (quark_ht, "extra_gtktype", GINT_TO_POINTER (QUARK_extra_gtktype));
 263         g_hash_table_insert (quark_ht, "extra_gtktype:steal", GINT_TO_POINTER (QUARK_extra_gtktype_STEAL));
 264         g_hash_table_insert (quark_ht, "override", GINT_TO_POINTER (QUARK_override));
 265         g_hash_table_insert (quark_ht, "link", GINT_TO_POINTER (QUARK_link));
 266         g_hash_table_insert (quark_ht, "export", GINT_TO_POINTER (QUARK_export));
 267         g_hash_table_insert (quark_ht, "scope", GINT_TO_POINTER (QUARK_scope));
 268         g_hash_table_insert (quark_ht, "method", GINT_TO_POINTER (QUARK_method));
 269         g_hash_table_insert (quark_ht, "mtype", GINT_TO_POINTER (QUARK_mtype));
 270         g_hash_table_insert (quark_ht, "mtype:steal", GINT_TO_POINTER (QUARK_mtype_STEAL));
 271         g_hash_table_insert (quark_ht, "gtktypes", GINT_TO_POINTER (QUARK_gtktypes));
 272         g_hash_table_insert (quark_ht, "gtktypes:steal", GINT_TO_POINTER (QUARK_gtktypes_STEAL));
 273         g_hash_table_insert (quark_ht, "signal_name", GINT_TO_POINTER (QUARK_signal_name));
 274         g_hash_table_insert (quark_ht, "signal_name:steal", GINT_TO_POINTER (QUARK_signal_name_STEAL));
 275         g_hash_table_insert (quark_ht, "id", GINT_TO_POINTER (QUARK_id));
 276         g_hash_table_insert (quark_ht, "id:steal", GINT_TO_POINTER (QUARK_id_STEAL));
 277         g_hash_table_insert (quark_ht, "args", GINT_TO_POINTER (QUARK_args));
 278         g_hash_table_insert (quark_ht, "args:steal", GINT_TO_POINTER (QUARK_args_STEAL));
 279         g_hash_table_insert (quark_ht, "funcattrs", GINT_TO_POINTER (QUARK_funcattrs));
 280         g_hash_table_insert (quark_ht, "funcattrs:steal", GINT_TO_POINTER (QUARK_funcattrs_STEAL));
 281         g_hash_table_insert (quark_ht, "onerror", GINT_TO_POINTER (QUARK_onerror));
 282         g_hash_table_insert (quark_ht, "onerror:steal", GINT_TO_POINTER (QUARK_onerror_STEAL));
 283         g_hash_table_insert (quark_ht, "defreturn", GINT_TO_POINTER (QUARK_defreturn));
 284         g_hash_table_insert (quark_ht, "defreturn:steal", GINT_TO_POINTER (QUARK_defreturn_STEAL));
 285         g_hash_table_insert (quark_ht, "ccode_line", GINT_TO_POINTER (QUARK_ccode_line));
 286         g_hash_table_insert (quark_ht, "vararg", GINT_TO_POINTER (QUARK_vararg));
 287         g_hash_table_insert (quark_ht, "unique_id", GINT_TO_POINTER (QUARK_unique_id));
 288         g_hash_table_insert (quark_ht, "bonobo_object_func", GINT_TO_POINTER (QUARK_bonobo_object_func));
 289         g_hash_table_insert (quark_ht, "interface", GINT_TO_POINTER (QUARK_interface));
 290         g_hash_table_insert (quark_ht, "interface:steal", GINT_TO_POINTER (QUARK_interface_STEAL));
 291         g_hash_table_insert (quark_ht, "vtype", GINT_TO_POINTER (QUARK_vtype));
 292         g_hash_table_insert (quark_ht, "vtype:steal", GINT_TO_POINTER (QUARK_vtype_STEAL));
 293         g_hash_table_insert (quark_ht, "glade_widget", GINT_TO_POINTER (QUARK_glade_widget));
 294         g_hash_table_insert (quark_ht, "destructor_unref", GINT_TO_POINTER (QUARK_destructor_unref));
 295         g_hash_table_insert (quark_ht, "destructor", GINT_TO_POINTER (QUARK_destructor));
 296         g_hash_table_insert (quark_ht, "destructor:steal", GINT_TO_POINTER (QUARK_destructor_STEAL));
 297         g_hash_table_insert (quark_ht, "destructor_line", GINT_TO_POINTER (QUARK_destructor_line));
 298         g_hash_table_insert (quark_ht, "destructor_simple", GINT_TO_POINTER (QUARK_destructor_simple));
 299         g_hash_table_insert (quark_ht, "initializer", GINT_TO_POINTER (QUARK_initializer));
 300         g_hash_table_insert (quark_ht, "initializer:steal", GINT_TO_POINTER (QUARK_initializer_STEAL));
 301         g_hash_table_insert (quark_ht, "initializer_line", GINT_TO_POINTER (QUARK_initializer_line));
 302         g_hash_table_insert (quark_ht, "initializer_simple", GINT_TO_POINTER (QUARK_initializer_simple));
 303         g_hash_table_insert (quark_ht, "etype", GINT_TO_POINTER (QUARK_etype));
 304         g_hash_table_insert (quark_ht, "etype:steal", GINT_TO_POINTER (QUARK_etype_STEAL));
 305         g_hash_table_insert (quark_ht, "prefix", GINT_TO_POINTER (QUARK_prefix));
 306         g_hash_table_insert (quark_ht, "prefix:steal", GINT_TO_POINTER (QUARK_prefix_STEAL));
 307         g_hash_table_insert (quark_ht, "values", GINT_TO_POINTER (QUARK_values));
 308         g_hash_table_insert (quark_ht, "values:steal", GINT_TO_POINTER (QUARK_values_STEAL));
 309         g_hash_table_insert (quark_ht, "value", GINT_TO_POINTER (QUARK_value));
 310         g_hash_table_insert (quark_ht, "value:steal", GINT_TO_POINTER (QUARK_value_STEAL));
 311         g_hash_table_insert (quark_ht, "ftype", GINT_TO_POINTER (QUARK_ftype));
 312         g_hash_table_insert (quark_ht, "ftype:steal", GINT_TO_POINTER (QUARK_ftype_STEAL));
 313 }
 314
 315 static Argument *
 316 copy_argument (Argument * self)
 317 {
 318         Argument * new;
 319         g_return_val_if_fail (self != NULL, NULL);
 320         g_return_val_if_fail (self->type == ARGUMENT_NODE, NULL);
 321         new = g_new0(Argument, 1);
 322         new->type = ARGUMENT_NODE;
 323         new->gtktype = g_strdup (self->gtktype);
 324         new->atype = copy_type (self->atype);
 325         new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 326         new->name = g_strdup (self->name);
 327         new->get = g_strdup (self->get);
 328         new->get_line = self->get_line;
 329         new->set = g_strdup (self->set);
 330         new->set_line = self->set_line;
 331         new->line_no = self->line_no;
 332         return new;
 333 }
 334
 335 static CCode *
 336 copy_ccode (CCode * self)
 337 {
 338         CCode * new;
 339         g_return_val_if_fail (self != NULL, NULL);
 340         g_return_val_if_fail (self->type == CCODE_NODE, NULL);
 341         new = g_new0(CCode, 1);
 342         new->type = CCODE_NODE;
 343         new->cctype = self->cctype;
 344         new->cbuf = g_strdup (self->cbuf);
 345         new->line_no = self->line_no;
 346         return new;
 347 }
 348
 349 static Check *
 350 copy_check (Check * self)
 351 {
 352         Check * new;
 353         g_return_val_if_fail (self != NULL, NULL);
 354         g_return_val_if_fail (self->type == CHECK_NODE, NULL);
 355         new = g_new0(Check, 1);
 356         new->type = CHECK_NODE;
 357         new->chtype = self->chtype;
 358         new->number = g_strdup (self->number);
 359         return new;
 360 }
 361
 362 static Class *
 363 copy_class (Class * self)
 364 {
 365         Class * new;
 366         g_return_val_if_fail (self != NULL, NULL);
 367         g_return_val_if_fail (self->type == CLASS_NODE, NULL);
 368         new = g_new0(Class, 1);
 369         new->type = CLASS_NODE;
 370         new->otype = g_strdup (self->otype);
 371         new->ptype = g_strdup (self->ptype);
 372         new->bonobo_object_class = g_strdup (self->bonobo_object_class);
 373         new->glade_xml = self->glade_xml;
 374         new->chunk_size = g_strdup (self->chunk_size);
 375         new->interfaces = g_list_copy (self->interfaces); COPY_LIST_VALS(new->interfaces, g_strdup);
 376         new->nodes = node_list_copy (self->nodes);
 377         new->abstract = self->abstract;
 378         return new;
 379 }
 380
 381 static EnumDef *
 382 copy_enumdef (EnumDef * self)
 383 {
 384         EnumDef * new;
 385         g_return_val_if_fail (self != NULL, NULL);
 386         g_return_val_if_fail (self->type == ENUMDEF_NODE, NULL);
 387         new = g_new0(EnumDef, 1);
 388         new->type = ENUMDEF_NODE;
 389         new->etype = g_strdup (self->etype);
 390         new->prefix = g_strdup (self->prefix);
 391         new->values = node_list_copy (self->values);
 392         return new;
 393 }
 394
 395 static EnumValue *
 396 copy_enumvalue (EnumValue * self)
 397 {
 398         EnumValue * new;
 399         g_return_val_if_fail (self != NULL, NULL);
 400         g_return_val_if_fail (self->type == ENUMVALUE_NODE, NULL);
 401         new = g_new0(EnumValue, 1);
 402         new->type = ENUMVALUE_NODE;
 403         new->name = g_strdup (self->name);
 404         new->value = g_strdup (self->value);
 405         return new;
 406 }
 407
 408 static Error *
 409 copy_error (Error * self)
 410 {
 411         Error * new;
 412         g_return_val_if_fail (self != NULL, NULL);
 413         g_return_val_if_fail (self->type == ERROR_NODE, NULL);
 414         new = g_new0(Error, 1);
 415         new->type = ERROR_NODE;
 416         new->etype = g_strdup (self->etype);
 417         new->prefix = g_strdup (self->prefix);
 418         new->values = g_list_copy (self->values); COPY_LIST_VALS(new->values, g_strdup);
 419         return new;
 420 }
 421
 422 static Flags *
 423 copy_flags (Flags * self)
 424 {
 425         Flags * new;
 426         g_return_val_if_fail (self != NULL, NULL);
 427         g_return_val_if_fail (self->type == FLAGS_NODE, NULL);
 428         new = g_new0(Flags, 1);
 429         new->type = FLAGS_NODE;
 430         new->ftype = g_strdup (self->ftype);
 431         new->prefix = g_strdup (self->prefix);
 432         new->values = g_list_copy (self->values); COPY_LIST_VALS(new->values, g_strdup);
 433         return new;
 434 }
 435
 436 static FuncArg *
 437 copy_funcarg (FuncArg * self)
 438 {
 439         FuncArg * new;
 440         g_return_val_if_fail (self != NULL, NULL);
 441         g_return_val_if_fail (self->type == FUNCARG_NODE, NULL);
 442         new = g_new0(FuncArg, 1);
 443         new->type = FUNCARG_NODE;
 444         new->atype = copy_type (self->atype);
 445         new->name = g_strdup (self->name);
 446         new->checks = node_list_copy (self->checks);
 447         return new;
 448 }
 449
 450 static Method *
 451 copy_method (Method * self)
 452 {
 453         Method * new;
 454         g_return_val_if_fail (self != NULL, NULL);
 455         g_return_val_if_fail (self->type == METHOD_NODE, NULL);
 456         new = g_new0(Method, 1);
 457         new->type = METHOD_NODE;
 458         new->scope = self->scope;
 459         new->method = self->method;
 460         new->mtype = copy_type (self->mtype);
 461         new->otype = g_strdup (self->otype);
 462         new->gtktypes = g_list_copy (self->gtktypes); COPY_LIST_VALS(new->gtktypes, g_strdup);
 463         new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 464         new->signal_name = g_strdup (self->signal_name);
 465         new->id = g_strdup (self->id);
 466         new->args = node_list_copy (self->args);
 467         new->funcattrs = g_strdup (self->funcattrs);
 468         new->onerror = g_strdup (self->onerror);
 469         new->defreturn = g_strdup (self->defreturn);
 470         new->cbuf = g_strdup (self->cbuf);
 471         new->line_no = self->line_no;
 472         new->ccode_line = self->ccode_line;
 473         new->vararg = self->vararg;
 474         new->unique_id = self->unique_id;
 475         new->bonobo_object_func = self->bonobo_object_func;
 476         new->interface = g_strdup (self->interface);
 477         return new;
 478 }
 479
 480 static Property *
 481 copy_property (Property * self)
 482 {
 483         Property * new;
 484         g_return_val_if_fail (self != NULL, NULL);
 485         g_return_val_if_fail (self->type == PROPERTY_NODE, NULL);
 486         new = g_new0(Property, 1);
 487         new->type = PROPERTY_NODE;
 488         new->gtktype = g_strdup (self->gtktype);
 489         new->ptype = copy_type (self->ptype);
 490         new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 491         new->name = g_strdup (self->name);
 492         new->canonical_name = g_strdup (self->canonical_name);
 493         new->nick = g_strdup (self->nick);
 494         new->blurb = g_strdup (self->blurb);
 495         new->minimum = g_strdup (self->minimum);
 496         new->maximum = g_strdup (self->maximum);
 497         new->default_value = g_strdup (self->default_value);
 498         new->extra_gtktype = g_strdup (self->extra_gtktype);
 499         new->override = self->override;
 500         new->link = self->link;
 501         new->export = self->export;
 502         new->get = g_strdup (self->get);
 503         new->get_line = self->get_line;
 504         new->set = g_strdup (self->set);
 505         new->set_line = self->set_line;
 506         new->line_no = self->line_no;
 507         return new;
 508 }
 509
 510 static Type *
 511 copy_type (Type * self)
 512 {
 513         Type * new;
 514         g_return_val_if_fail (self != NULL, NULL);
 515         g_return_val_if_fail (self->type == TYPE_NODE, NULL);
 516         new = g_new0(Type, 1);
 517         new->type = TYPE_NODE;
 518         new->name = g_strdup (self->name);
 519         new->pointer = g_strdup (self->pointer);
 520         new->postfix = g_strdup (self->postfix);
 521         return new;
 522 }
 523
 524 static Variable *
 525 copy_variable (Variable * self)
 526 {
 527         Variable * new;
 528         g_return_val_if_fail (self != NULL, NULL);
 529         g_return_val_if_fail (self->type == VARIABLE_NODE, NULL);
 530         new = g_new0(Variable, 1);
 531         new->type = VARIABLE_NODE;
 532         new->scope = self->scope;
 533         new->vtype = copy_type (self->vtype);
 534         new->glade_widget = self->glade_widget;
 535         new->id = g_strdup (self->id);
 536         new->line_no = self->line_no;
 537         new->destructor_unref = self->destructor_unref;
 538         new->destructor = g_strdup (self->destructor);
 539         new->destructor_line = self->destructor_line;
 540         new->destructor_simple = self->destructor_simple;
 541         new->initializer = g_strdup (self->initializer);
 542         new->initializer_line = self->initializer_line;
 543         new->initializer_simple = self->initializer_simple;
 544         return new;
 545 }
 546
 547 void
 548 free_argument (Argument * self)
 549 {
 550         g_return_if_fail (self != NULL);
 551         g_return_if_fail (self->type == ARGUMENT_NODE);
 552         g_free (self->gtktype);
 553         free_type (self->atype);
 554         g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
 555         g_free (self->name);
 556         g_free (self->get);
 557         g_free (self->set);
 558         g_free (self);
 559 }
 560
 561 void
 562 free_ccode (CCode * self)
 563 {
 564         g_return_if_fail (self != NULL);
 565         g_return_if_fail (self->type == CCODE_NODE);
 566         g_free (self->cbuf);
 567         g_free (self);
 568 }
 569
 570 void
 571 free_check (Check * self)
 572 {
 573         g_return_if_fail (self != NULL);
 574         g_return_if_fail (self->type == CHECK_NODE);
 575         g_free (self->number);
 576         g_free (self);
 577 }
 578
 579 void
 580 free_class (Class * self)
 581 {
 582         g_return_if_fail (self != NULL);
 583         g_return_if_fail (self->type == CLASS_NODE);
 584         g_free (self->otype);
 585         g_free (self->ptype);
 586         g_free (self->bonobo_object_class);
 587         g_free (self->chunk_size);
 588         g_list_foreach (self->interfaces, (GFunc)g_free, NULL); g_list_free (self->interfaces);
 589         node_list_free (self->nodes);
 590         g_free (self);
 591 }
 592
 593 void
 594 free_enumdef (EnumDef * self)
 595 {
 596         g_return_if_fail (self != NULL);
 597         g_return_if_fail (self->type == ENUMDEF_NODE);
 598         g_free (self->etype);
 599         g_free (self->prefix);
 600         node_list_free (self->values);
 601         g_free (self);
 602 }
 603
 604 void
 605 free_enumvalue (EnumValue * self)
 606 {
 607         g_return_if_fail (self != NULL);
 608         g_return_if_fail (self->type == ENUMVALUE_NODE);
 609         g_free (self->name);
 610         g_free (self->value);
 611         g_free (self);
 612 }
 613
 614 void
 615 free_error (Error * self)
 616 {
 617         g_return_if_fail (self != NULL);
 618         g_return_if_fail (self->type == ERROR_NODE);
 619         g_free (self->etype);
 620         g_free (self->prefix);
 621         g_list_foreach (self->values, (GFunc)g_free, NULL); g_list_free (self->values);
 622         g_free (self);
 623 }
 624
 625 void
 626 free_flags (Flags * self)
 627 {
 628         g_return_if_fail (self != NULL);
 629         g_return_if_fail (self->type == FLAGS_NODE);
 630         g_free (self->ftype);
 631         g_free (self->prefix);
 632         g_list_foreach (self->values, (GFunc)g_free, NULL); g_list_free (self->values);
 633         g_free (self);
 634 }
 635
 636 void
 637 free_funcarg (FuncArg * self)
 638 {
 639         g_return_if_fail (self != NULL);
 640         g_return_if_fail (self->type == FUNCARG_NODE);
 641         free_type (self->atype);
 642         g_free (self->name);
 643         node_list_free (self->checks);
 644         g_free (self);
 645 }
 646
 647 void
 648 free_method (Method * self)
 649 {
 650         g_return_if_fail (self != NULL);
 651         g_return_if_fail (self->type == METHOD_NODE);
 652         free_type (self->mtype);
 653         g_free (self->otype);
 654         g_list_foreach (self->gtktypes, (GFunc)g_free, NULL); g_list_free (self->gtktypes);
 655         g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
 656         g_free (self->signal_name);
 657         g_free (self->id);
 658         node_list_free (self->args);
 659         g_free (self->funcattrs);
 660         g_free (self->onerror);
 661         g_free (self->defreturn);
 662         g_free (self->cbuf);
 663         g_free (self->interface);
 664         g_free (self);
 665 }
 666
 667 void
 668 free_property (Property * self)
 669 {
 670         g_return_if_fail (self != NULL);
 671         g_return_if_fail (self->type == PROPERTY_NODE);
 672         g_free (self->gtktype);
 673         free_type (self->ptype);
 674         g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
 675         g_free (self->name);
 676         g_free (self->canonical_name);
 677         g_free (self->nick);
 678         g_free (self->blurb);
 679         g_free (self->minimum);
 680         g_free (self->maximum);
 681         g_free (self->default_value);
 682         g_free (self->extra_gtktype);
 683         g_free (self->get);
 684         g_free (self->set);
 685         g_free (self);
 686 }
 687
 688 void
 689 free_type (Type * self)
 690 {
 691         g_return_if_fail (self != NULL);
 692         g_return_if_fail (self->type == TYPE_NODE);
 693         g_free (self->name);
 694         g_free (self->pointer);
 695         g_free (self->postfix);
 696         g_free (self);
 697 }
 698
 699 void
 700 free_variable (Variable * self)
 701 {
 702         g_return_if_fail (self != NULL);
 703         g_return_if_fail (self->type == VARIABLE_NODE);
 704         free_type (self->vtype);
 705         g_free (self->id);
 706         g_free (self->destructor);
 707         g_free (self->initializer);
 708         g_free (self);
 709 }
 710
 711 static void
 712 setv_argument (Argument * self, va_list __ap)
 713 {
 714         int quark;
 715         const char *arg;
 716         ensure_quarks ();
 717         while ((arg = va_arg (__ap, char *)) != NULL) {
 718                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 719                 switch (quark) {
 720                 case QUARK_gtktype: {
 721                         char * gtktype = va_arg (__ap, char *);
 722                         char * __old_value = self->gtktype;
 723                         self->gtktype = g_strdup (gtktype);
 724                         g_free (__old_value);
 725                         break;
 726                 }
 727                 case QUARK_gtktype_STEAL: {
 728                         char * gtktype = va_arg (__ap, char *);
 729                         self->gtktype = gtktype;
 730                         break;
 731                 }
 732                 case QUARK_atype: {
 733                         Type * atype = va_arg (__ap, Type *);
 734                         Type * __old_value = self->atype;
 735                         self->atype = copy_type (atype);
 736                         free_type (__old_value);
 737                         break;
 738                 }
 739                 case QUARK_atype_STEAL: {
 740                         Type * atype = va_arg (__ap, Type *);
 741                         self->atype = atype;
 742                         break;
 743                 }
 744                 case QUARK_flags: {
 745                         GList * flags = va_arg (__ap, GList *);
 746                         GList * __old_value = self->flags;
 747                         self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
 748                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
 749                         break;
 750                 }
 751                 case QUARK_flags_STEAL: {
 752                         GList * flags = va_arg (__ap, GList *);
 753                         self->flags = flags;
 754                         break;
 755                 }
 756                 case QUARK_name: {
 757                         char * name = va_arg (__ap, char *);
 758                         char * __old_value = self->name;
 759                         self->name = g_strdup (name);
 760                         g_free (__old_value);
 761                         break;
 762                 }
 763                 case QUARK_name_STEAL: {
 764                         char * name = va_arg (__ap, char *);
 765                         self->name = name;
 766                         break;
 767                 }
 768                 case QUARK_get: {
 769                         char * get = va_arg (__ap, char *);
 770                         char * __old_value = self->get;
 771                         self->get = g_strdup (get);
 772                         g_free (__old_value);
 773                         break;
 774                 }
 775                 case QUARK_get_STEAL: {
 776                         char * get = va_arg (__ap, char *);
 777                         self->get = get;
 778                         break;
 779                 }
 780                 case QUARK_get_line: {
 781                         int get_line = va_arg (__ap, int);
 782                         self->get_line = get_line;
 783                         break;
 784                 }
 785                 case QUARK_set: {
 786                         char * set = va_arg (__ap, char *);
 787                         char * __old_value = self->set;
 788                         self->set = g_strdup (set);
 789                         g_free (__old_value);
 790                         break;
 791                 }
 792                 case QUARK_set_STEAL: {
 793                         char * set = va_arg (__ap, char *);
 794                         self->set = set;
 795                         break;
 796                 }
 797                 case QUARK_set_line: {
 798                         int set_line = va_arg (__ap, int);
 799                         self->set_line = set_line;
 800                         break;
 801                 }
 802                 case QUARK_line_no: {
 803                         int line_no = va_arg (__ap, int);
 804                         self->line_no = line_no;
 805                         break;
 806                 }
 807                 default:
 808                         g_warning ("Argument named 'Argument::%s' does not exist", arg);
 809                         break;
 810                 }
 811         }
 812 }
 813
 814 static void
 815 setv_ccode (CCode * self, va_list __ap)
 816 {
 817         int quark;
 818         const char *arg;
 819         ensure_quarks ();
 820         while ((arg = va_arg (__ap, char *)) != NULL) {
 821                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 822                 switch (quark) {
 823                 case QUARK_cctype: {
 824                         int cctype = va_arg (__ap, int);
 825                         self->cctype = cctype;
 826                         break;
 827                 }
 828                 case QUARK_cbuf: {
 829                         char * cbuf = va_arg (__ap, char *);
 830                         char * __old_value = self->cbuf;
 831                         self->cbuf = g_strdup (cbuf);
 832                         g_free (__old_value);
 833                         break;
 834                 }
 835                 case QUARK_cbuf_STEAL: {
 836                         char * cbuf = va_arg (__ap, char *);
 837                         self->cbuf = cbuf;
 838                         break;
 839                 }
 840                 case QUARK_line_no: {
 841                         int line_no = va_arg (__ap, int);
 842                         self->line_no = line_no;
 843                         break;
 844                 }
 845                 default:
 846                         g_warning ("Argument named 'CCode::%s' does not exist", arg);
 847                         break;
 848                 }
 849         }
 850 }
 851
 852 static void
 853 setv_check (Check * self, va_list __ap)
 854 {
 855         int quark;
 856         const char *arg;
 857         ensure_quarks ();
 858         while ((arg = va_arg (__ap, char *)) != NULL) {
 859                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 860                 switch (quark) {
 861                 case QUARK_chtype: {
 862                         int chtype = va_arg (__ap, int);
 863                         self->chtype = chtype;
 864                         break;
 865                 }
 866                 case QUARK_number: {
 867                         char * number = va_arg (__ap, char *);
 868                         char * __old_value = self->number;
 869                         self->number = g_strdup (number);
 870                         g_free (__old_value);
 871                         break;
 872                 }
 873                 case QUARK_number_STEAL: {
 874                         char * number = va_arg (__ap, char *);
 875                         self->number = number;
 876                         break;
 877                 }
 878                 default:
 879                         g_warning ("Argument named 'Check::%s' does not exist", arg);
 880                         break;
 881                 }
 882         }
 883 }
 884
 885 static void
 886 setv_class (Class * self, va_list __ap)
 887 {
 888         int quark;
 889         const char *arg;
 890         ensure_quarks ();
 891         while ((arg = va_arg (__ap, char *)) != NULL) {
 892                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 893                 switch (quark) {
 894                 case QUARK_otype: {
 895                         char * otype = va_arg (__ap, char *);
 896                         char * __old_value = self->otype;
 897                         self->otype = g_strdup (otype);
 898                         g_free (__old_value);
 899                         break;
 900                 }
 901                 case QUARK_otype_STEAL: {
 902                         char * otype = va_arg (__ap, char *);
 903                         self->otype = otype;
 904                         break;
 905                 }
 906                 case QUARK_ptype: {
 907                         char * ptype = va_arg (__ap, char *);
 908                         char * __old_value = self->ptype;
 909                         self->ptype = g_strdup (ptype);
 910                         g_free (__old_value);
 911                         break;
 912                 }
 913                 case QUARK_ptype_STEAL: {
 914                         char * ptype = va_arg (__ap, char *);
 915                         self->ptype = ptype;
 916                         break;
 917                 }
 918                 case QUARK_bonobo_object_class: {
 919                         char * bonobo_object_class = va_arg (__ap, char *);
 920                         char * __old_value = self->bonobo_object_class;
 921                         self->bonobo_object_class = g_strdup (bonobo_object_class);
 922                         g_free (__old_value);
 923                         break;
 924                 }
 925                 case QUARK_bonobo_object_class_STEAL: {
 926                         char * bonobo_object_class = va_arg (__ap, char *);
 927                         self->bonobo_object_class = bonobo_object_class;
 928                         break;
 929                 }
 930                 case QUARK_glade_xml: {
 931                         gboolean glade_xml = va_arg (__ap, gboolean);
 932                         self->glade_xml = glade_xml;
 933                         break;
 934                 }
 935                 case QUARK_chunk_size: {
 936                         char * chunk_size = va_arg (__ap, char *);
 937                         char * __old_value = self->chunk_size;
 938                         self->chunk_size = g_strdup (chunk_size);
 939                         g_free (__old_value);
 940                         break;
 941                 }
 942                 case QUARK_chunk_size_STEAL: {
 943                         char * chunk_size = va_arg (__ap, char *);
 944                         self->chunk_size = chunk_size;
 945                         break;
 946                 }
 947                 case QUARK_interfaces: {
 948                         GList * interfaces = va_arg (__ap, GList *);
 949                         GList * __old_value = self->interfaces;
 950                         self->interfaces = g_list_copy (interfaces); COPY_LIST_VALS(self->interfaces, g_strdup);
 951                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
 952                         break;
 953                 }
 954                 case QUARK_interfaces_STEAL: {
 955                         GList * interfaces = va_arg (__ap, GList *);
 956                         self->interfaces = interfaces;
 957                         break;
 958                 }
 959                 case QUARK_nodes: {
 960                         GList * nodes = va_arg (__ap, GList *);
 961                         GList * __old_value = self->nodes;
 962                         self->nodes = node_list_copy (nodes);
 963                         node_list_free (__old_value);
 964                         break;
 965                 }
 966                 case QUARK_nodes_STEAL: {
 967                         GList * nodes = va_arg (__ap, GList *);
 968                         self->nodes = nodes;
 969                         break;
 970                 }
 971                 case QUARK_abstract: {
 972                         gboolean abstract = va_arg (__ap, gboolean);
 973                         self->abstract = abstract;
 974                         break;
 975                 }
 976                 default:
 977                         g_warning ("Argument named 'Class::%s' does not exist", arg);
 978                         break;
 979                 }
 980         }
 981 }
 982
 983 static void
 984 setv_enumdef (EnumDef * self, va_list __ap)
 985 {
 986         int quark;
 987         const char *arg;
 988         ensure_quarks ();
 989         while ((arg = va_arg (__ap, char *)) != NULL) {
 990                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
 991                 switch (quark) {
 992                 case QUARK_etype: {
 993                         char * etype = va_arg (__ap, char *);
 994                         char * __old_value = self->etype;
 995                         self->etype = g_strdup (etype);
 996                         g_free (__old_value);
 997                         break;
 998                 }
 999                 case QUARK_etype_STEAL: {
1000                         char * etype = va_arg (__ap, char *);
1001                         self->etype = etype;
1002                         break;
1003                 }
1004                 case QUARK_prefix: {
1005                         char * prefix = va_arg (__ap, char *);
1006                         char * __old_value = self->prefix;
1007                         self->prefix = g_strdup (prefix);
1008                         g_free (__old_value);
1009                         break;
1010                 }
1011                 case QUARK_prefix_STEAL: {
1012                         char * prefix = va_arg (__ap, char *);
1013                         self->prefix = prefix;
1014                         break;
1015                 }
1016                 case QUARK_values: {
1017                         GList * values = va_arg (__ap, GList *);
1018                         GList * __old_value = self->values;
1019                         self->values = node_list_copy (values);
1020                         node_list_free (__old_value);
1021                         break;
1022                 }
1023                 case QUARK_values_STEAL: {
1024                         GList * values = va_arg (__ap, GList *);
1025                         self->values = values;
1026                         break;
1027                 }
1028                 default:
1029                         g_warning ("Argument named 'EnumDef::%s' does not exist", arg);
1030                         break;
1031                 }
1032         }
1033 }
1034
1035 static void
1036 setv_enumvalue (EnumValue * self, va_list __ap)
1037 {
1038         int quark;
1039         const char *arg;
1040         ensure_quarks ();
1041         while ((arg = va_arg (__ap, char *)) != NULL) {
1042                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1043                 switch (quark) {
1044                 case QUARK_name: {
1045                         char * name = va_arg (__ap, char *);
1046                         char * __old_value = self->name;
1047                         self->name = g_strdup (name);
1048                         g_free (__old_value);
1049                         break;
1050                 }
1051                 case QUARK_name_STEAL: {
1052                         char * name = va_arg (__ap, char *);
1053                         self->name = name;
1054                         break;
1055                 }
1056                 case QUARK_value: {
1057                         char * value = va_arg (__ap, char *);
1058                         char * __old_value = self->value;
1059                         self->value = g_strdup (value);
1060                         g_free (__old_value);
1061                         break;
1062                 }
1063                 case QUARK_value_STEAL: {
1064                         char * value = va_arg (__ap, char *);
1065                         self->value = value;
1066                         break;
1067                 }
1068                 default:
1069                         g_warning ("Argument named 'EnumValue::%s' does not exist", arg);
1070                         break;
1071                 }
1072         }
1073 }
1074
1075 static void
1076 setv_error (Error * self, va_list __ap)
1077 {
1078         int quark;
1079         const char *arg;
1080         ensure_quarks ();
1081         while ((arg = va_arg (__ap, char *)) != NULL) {
1082                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1083                 switch (quark) {
1084                 case QUARK_etype: {
1085                         char * etype = va_arg (__ap, char *);
1086                         char * __old_value = self->etype;
1087                         self->etype = g_strdup (etype);
1088                         g_free (__old_value);
1089                         break;
1090                 }
1091                 case QUARK_etype_STEAL: {
1092                         char * etype = va_arg (__ap, char *);
1093                         self->etype = etype;
1094                         break;
1095                 }
1096                 case QUARK_prefix: {
1097                         char * prefix = va_arg (__ap, char *);
1098                         char * __old_value = self->prefix;
1099                         self->prefix = g_strdup (prefix);
1100                         g_free (__old_value);
1101                         break;
1102                 }
1103                 case QUARK_prefix_STEAL: {
1104                         char * prefix = va_arg (__ap, char *);
1105                         self->prefix = prefix;
1106                         break;
1107                 }
1108                 case QUARK_values: {
1109                         GList * values = va_arg (__ap, GList *);
1110                         GList * __old_value = self->values;
1111                         self->values = g_list_copy (values); COPY_LIST_VALS(self->values, g_strdup);
1112                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
1113                         break;
1114                 }
1115                 case QUARK_values_STEAL: {
1116                         GList * values = va_arg (__ap, GList *);
1117                         self->values = values;
1118                         break;
1119                 }
1120                 default:
1121                         g_warning ("Argument named 'Error::%s' does not exist", arg);
1122                         break;
1123                 }
1124         }
1125 }
1126
1127 static void
1128 setv_flags (Flags * self, va_list __ap)
1129 {
1130         int quark;
1131         const char *arg;
1132         ensure_quarks ();
1133         while ((arg = va_arg (__ap, char *)) != NULL) {
1134                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1135                 switch (quark) {
1136                 case QUARK_ftype: {
1137                         char * ftype = va_arg (__ap, char *);
1138                         char * __old_value = self->ftype;
1139                         self->ftype = g_strdup (ftype);
1140                         g_free (__old_value);
1141                         break;
1142                 }
1143                 case QUARK_ftype_STEAL: {
1144                         char * ftype = va_arg (__ap, char *);
1145                         self->ftype = ftype;
1146                         break;
1147                 }
1148                 case QUARK_prefix: {
1149                         char * prefix = va_arg (__ap, char *);
1150                         char * __old_value = self->prefix;
1151                         self->prefix = g_strdup (prefix);
1152                         g_free (__old_value);
1153                         break;
1154                 }
1155                 case QUARK_prefix_STEAL: {
1156                         char * prefix = va_arg (__ap, char *);
1157                         self->prefix = prefix;
1158                         break;
1159                 }
1160                 case QUARK_values: {
1161                         GList * values = va_arg (__ap, GList *);
1162                         GList * __old_value = self->values;
1163                         self->values = g_list_copy (values); COPY_LIST_VALS(self->values, g_strdup);
1164                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
1165                         break;
1166                 }
1167                 case QUARK_values_STEAL: {
1168                         GList * values = va_arg (__ap, GList *);
1169                         self->values = values;
1170                         break;
1171                 }
1172                 default:
1173                         g_warning ("Argument named 'Flags::%s' does not exist", arg);
1174                         break;
1175                 }
1176         }
1177 }
1178
1179 static void
1180 setv_funcarg (FuncArg * self, va_list __ap)
1181 {
1182         int quark;
1183         const char *arg;
1184         ensure_quarks ();
1185         while ((arg = va_arg (__ap, char *)) != NULL) {
1186                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1187                 switch (quark) {
1188                 case QUARK_atype: {
1189                         Type * atype = va_arg (__ap, Type *);
1190                         Type * __old_value = self->atype;
1191                         self->atype = copy_type (atype);
1192                         free_type (__old_value);
1193                         break;
1194                 }
1195                 case QUARK_atype_STEAL: {
1196                         Type * atype = va_arg (__ap, Type *);
1197                         self->atype = atype;
1198                         break;
1199                 }
1200                 case QUARK_name: {
1201                         char * name = va_arg (__ap, char *);
1202                         char * __old_value = self->name;
1203                         self->name = g_strdup (name);
1204                         g_free (__old_value);
1205                         break;
1206                 }
1207                 case QUARK_name_STEAL: {
1208                         char * name = va_arg (__ap, char *);
1209                         self->name = name;
1210                         break;
1211                 }
1212                 case QUARK_checks: {
1213                         GList * checks = va_arg (__ap, GList *);
1214                         GList * __old_value = self->checks;
1215                         self->checks = node_list_copy (checks);
1216                         node_list_free (__old_value);
1217                         break;
1218                 }
1219                 case QUARK_checks_STEAL: {
1220                         GList * checks = va_arg (__ap, GList *);
1221                         self->checks = checks;
1222                         break;
1223                 }
1224                 default:
1225                         g_warning ("Argument named 'FuncArg::%s' does not exist", arg);
1226                         break;
1227                 }
1228         }
1229 }
1230
1231 static void
1232 setv_method (Method * self, va_list __ap)
1233 {
1234         int quark;
1235         const char *arg;
1236         ensure_quarks ();
1237         while ((arg = va_arg (__ap, char *)) != NULL) {
1238                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1239                 switch (quark) {
1240                 case QUARK_scope: {
1241                         int scope = va_arg (__ap, int);
1242                         self->scope = scope;
1243                         break;
1244                 }
1245                 case QUARK_method: {
1246                         int method = va_arg (__ap, int);
1247                         self->method = method;
1248                         break;
1249                 }
1250                 case QUARK_mtype: {
1251                         Type * mtype = va_arg (__ap, Type *);
1252                         Type * __old_value = self->mtype;
1253                         self->mtype = copy_type (mtype);
1254                         free_type (__old_value);
1255                         break;
1256                 }
1257                 case QUARK_mtype_STEAL: {
1258                         Type * mtype = va_arg (__ap, Type *);
1259                         self->mtype = mtype;
1260                         break;
1261                 }
1262                 case QUARK_otype: {
1263                         char * otype = va_arg (__ap, char *);
1264                         char * __old_value = self->otype;
1265                         self->otype = g_strdup (otype);
1266                         g_free (__old_value);
1267                         break;
1268                 }
1269                 case QUARK_otype_STEAL: {
1270                         char * otype = va_arg (__ap, char *);
1271                         self->otype = otype;
1272                         break;
1273                 }
1274                 case QUARK_gtktypes: {
1275                         GList * gtktypes = va_arg (__ap, GList *);
1276                         GList * __old_value = self->gtktypes;
1277                         self->gtktypes = g_list_copy (gtktypes); COPY_LIST_VALS(self->gtktypes, g_strdup);
1278                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
1279                         break;
1280                 }
1281                 case QUARK_gtktypes_STEAL: {
1282                         GList * gtktypes = va_arg (__ap, GList *);
1283                         self->gtktypes = gtktypes;
1284                         break;
1285                 }
1286                 case QUARK_flags: {
1287                         GList * flags = va_arg (__ap, GList *);
1288                         GList * __old_value = self->flags;
1289                         self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
1290                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
1291                         break;
1292                 }
1293                 case QUARK_flags_STEAL: {
1294                         GList * flags = va_arg (__ap, GList *);
1295                         self->flags = flags;
1296                         break;
1297                 }
1298                 case QUARK_signal_name: {
1299                         char * signal_name = va_arg (__ap, char *);
1300                         char * __old_value = self->signal_name;
1301                         self->signal_name = g_strdup (signal_name);
1302                         g_free (__old_value);
1303                         break;
1304                 }
1305                 case QUARK_signal_name_STEAL: {
1306                         char * signal_name = va_arg (__ap, char *);
1307                         self->signal_name = signal_name;
1308                         break;
1309                 }
1310                 case QUARK_id: {
1311                         char * id = va_arg (__ap, char *);
1312                         char * __old_value = self->id;
1313                         self->id = g_strdup (id);
1314                         g_free (__old_value);
1315                         break;
1316                 }
1317                 case QUARK_id_STEAL: {
1318                         char * id = va_arg (__ap, char *);
1319                         self->id = id;
1320                         break;
1321                 }
1322                 case QUARK_args: {
1323                         GList * args = va_arg (__ap, GList *);
1324                         GList * __old_value = self->args;
1325                         self->args = node_list_copy (args);
1326                         node_list_free (__old_value);
1327                         break;
1328                 }
1329                 case QUARK_args_STEAL: {
1330                         GList * args = va_arg (__ap, GList *);
1331                         self->args = args;
1332                         break;
1333                 }
1334                 case QUARK_funcattrs: {
1335                         char * funcattrs = va_arg (__ap, char *);
1336                         char * __old_value = self->funcattrs;
1337                         self->funcattrs = g_strdup (funcattrs);
1338                         g_free (__old_value);
1339                         break;
1340                 }
1341                 case QUARK_funcattrs_STEAL: {
1342                         char * funcattrs = va_arg (__ap, char *);
1343                         self->funcattrs = funcattrs;
1344                         break;
1345                 }
1346                 case QUARK_onerror: {
1347                         char * onerror = va_arg (__ap, char *);
1348                         char * __old_value = self->onerror;
1349                         self->onerror = g_strdup (onerror);
1350                         g_free (__old_value);
1351                         break;
1352                 }
1353                 case QUARK_onerror_STEAL: {
1354                         char * onerror = va_arg (__ap, char *);
1355                         self->onerror = onerror;
1356                         break;
1357                 }
1358                 case QUARK_defreturn: {
1359                         char * defreturn = va_arg (__ap, char *);
1360                         char * __old_value = self->defreturn;
1361                         self->defreturn = g_strdup (defreturn);
1362                         g_free (__old_value);
1363                         break;
1364                 }
1365                 case QUARK_defreturn_STEAL: {
1366                         char * defreturn = va_arg (__ap, char *);
1367                         self->defreturn = defreturn;
1368                         break;
1369                 }
1370                 case QUARK_cbuf: {
1371                         char * cbuf = va_arg (__ap, char *);
1372                         char * __old_value = self->cbuf;
1373                         self->cbuf = g_strdup (cbuf);
1374                         g_free (__old_value);
1375                         break;
1376                 }
1377                 case QUARK_cbuf_STEAL: {
1378                         char * cbuf = va_arg (__ap, char *);
1379                         self->cbuf = cbuf;
1380                         break;
1381                 }
1382                 case QUARK_line_no: {
1383                         int line_no = va_arg (__ap, int);
1384                         self->line_no = line_no;
1385                         break;
1386                 }
1387                 case QUARK_ccode_line: {
1388                         int ccode_line = va_arg (__ap, int);
1389                         self->ccode_line = ccode_line;
1390                         break;
1391                 }
1392                 case QUARK_vararg: {
1393                         gboolean vararg = va_arg (__ap, gboolean);
1394                         self->vararg = vararg;
1395                         break;
1396                 }
1397                 case QUARK_unique_id: {
1398                         int unique_id = va_arg (__ap, int);
1399                         self->unique_id = unique_id;
1400                         break;
1401                 }
1402                 case QUARK_bonobo_object_func: {
1403                         gboolean bonobo_object_func = va_arg (__ap, gboolean);
1404                         self->bonobo_object_func = bonobo_object_func;
1405                         break;
1406                 }
1407                 case QUARK_interface: {
1408                         char * interface = va_arg (__ap, char *);
1409                         char * __old_value = self->interface;
1410                         self->interface = g_strdup (interface);
1411                         g_free (__old_value);
1412                         break;
1413                 }
1414                 case QUARK_interface_STEAL: {
1415                         char * interface = va_arg (__ap, char *);
1416                         self->interface = interface;
1417                         break;
1418                 }
1419                 default:
1420                         g_warning ("Argument named 'Method::%s' does not exist", arg);
1421                         break;
1422                 }
1423         }
1424 }
1425
1426 static void
1427 setv_property (Property * self, va_list __ap)
1428 {
1429         int quark;
1430         const char *arg;
1431         ensure_quarks ();
1432         while ((arg = va_arg (__ap, char *)) != NULL) {
1433                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1434                 switch (quark) {
1435                 case QUARK_gtktype: {
1436                         char * gtktype = va_arg (__ap, char *);
1437                         char * __old_value = self->gtktype;
1438                         self->gtktype = g_strdup (gtktype);
1439                         g_free (__old_value);
1440                         break;
1441                 }
1442                 case QUARK_gtktype_STEAL: {
1443                         char * gtktype = va_arg (__ap, char *);
1444                         self->gtktype = gtktype;
1445                         break;
1446                 }
1447                 case QUARK_ptype: {
1448                         Type * ptype = va_arg (__ap, Type *);
1449                         Type * __old_value = self->ptype;
1450                         self->ptype = copy_type (ptype);
1451                         free_type (__old_value);
1452                         break;
1453                 }
1454                 case QUARK_ptype_STEAL: {
1455                         Type * ptype = va_arg (__ap, Type *);
1456                         self->ptype = ptype;
1457                         break;
1458                 }
1459                 case QUARK_flags: {
1460                         GList * flags = va_arg (__ap, GList *);
1461                         GList * __old_value = self->flags;
1462                         self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
1463                         g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
1464                         break;
1465                 }
1466                 case QUARK_flags_STEAL: {
1467                         GList * flags = va_arg (__ap, GList *);
1468                         self->flags = flags;
1469                         break;
1470                 }
1471                 case QUARK_name: {
1472                         char * name = va_arg (__ap, char *);
1473                         char * __old_value = self->name;
1474                         self->name = g_strdup (name);
1475                         g_free (__old_value);
1476                         break;
1477                 }
1478                 case QUARK_name_STEAL: {
1479                         char * name = va_arg (__ap, char *);
1480                         self->name = name;
1481                         break;
1482                 }
1483                 case QUARK_canonical_name: {
1484                         char * canonical_name = va_arg (__ap, char *);
1485                         char * __old_value = self->canonical_name;
1486                         self->canonical_name = g_strdup (canonical_name);
1487                         g_free (__old_value);
1488                         break;
1489                 }
1490                 case QUARK_canonical_name_STEAL: {
1491                         char * canonical_name = va_arg (__ap, char *);
1492                         self->canonical_name = canonical_name;
1493                         break;
1494                 }
1495                 case QUARK_nick: {
1496                         char * nick = va_arg (__ap, char *);
1497                         char * __old_value = self->nick;
1498                         self->nick = g_strdup (nick);
1499                         g_free (__old_value);
1500                         break;
1501                 }
1502                 case QUARK_nick_STEAL: {
1503                         char * nick = va_arg (__ap, char *);
1504                         self->nick = nick;
1505                         break;
1506                 }
1507                 case QUARK_blurb: {
1508                         char * blurb = va_arg (__ap, char *);
1509                         char * __old_value = self->blurb;
1510                         self->blurb = g_strdup (blurb);
1511                         g_free (__old_value);
1512                         break;
1513                 }
1514                 case QUARK_blurb_STEAL: {
1515                         char * blurb = va_arg (__ap, char *);
1516                         self->blurb = blurb;
1517                         break;
1518                 }
1519                 case QUARK_minimum: {
1520                         char * minimum = va_arg (__ap, char *);
1521                         char * __old_value = self->minimum;
1522                         self->minimum = g_strdup (minimum);
1523                         g_free (__old_value);
1524                         break;
1525                 }
1526                 case QUARK_minimum_STEAL: {
1527                         char * minimum = va_arg (__ap, char *);
1528                         self->minimum = minimum;
1529                         break;
1530                 }
1531                 case QUARK_maximum: {
1532                         char * maximum = va_arg (__ap, char *);
1533                         char * __old_value = self->maximum;
1534                         self->maximum = g_strdup (maximum);
1535                         g_free (__old_value);
1536                         break;
1537                 }
1538                 case QUARK_maximum_STEAL: {
1539                         char * maximum = va_arg (__ap, char *);
1540                         self->maximum = maximum;
1541                         break;
1542                 }
1543                 case QUARK_default_value: {
1544                         char * default_value = va_arg (__ap, char *);
1545                         char * __old_value = self->default_value;
1546                         self->default_value = g_strdup (default_value);
1547                         g_free (__old_value);
1548                         break;
1549                 }
1550                 case QUARK_default_value_STEAL: {
1551                         char * default_value = va_arg (__ap, char *);
1552                         self->default_value = default_value;
1553                         break;
1554                 }
1555                 case QUARK_extra_gtktype: {
1556                         char * extra_gtktype = va_arg (__ap, char *);
1557                         char * __old_value = self->extra_gtktype;
1558                         self->extra_gtktype = g_strdup (extra_gtktype);
1559                         g_free (__old_value);
1560                         break;
1561                 }
1562                 case QUARK_extra_gtktype_STEAL: {
1563                         char * extra_gtktype = va_arg (__ap, char *);
1564                         self->extra_gtktype = extra_gtktype;
1565                         break;
1566                 }
1567                 case QUARK_override: {
1568                         gboolean override = va_arg (__ap, gboolean);
1569                         self->override = override;
1570                         break;
1571                 }
1572                 case QUARK_link: {
1573                         gboolean link = va_arg (__ap, gboolean);
1574                         self->link = link;
1575                         break;
1576                 }
1577                 case QUARK_export: {
1578                         gboolean export = va_arg (__ap, gboolean);
1579                         self->export = export;
1580                         break;
1581                 }
1582                 case QUARK_get: {
1583                         char * get = va_arg (__ap, char *);
1584                         char * __old_value = self->get;
1585                         self->get = g_strdup (get);
1586                         g_free (__old_value);
1587                         break;
1588                 }
1589                 case QUARK_get_STEAL: {
1590                         char * get = va_arg (__ap, char *);
1591                         self->get = get;
1592                         break;
1593                 }
1594                 case QUARK_get_line: {
1595                         int get_line = va_arg (__ap, int);
1596                         self->get_line = get_line;
1597                         break;
1598                 }
1599                 case QUARK_set: {
1600                         char * set = va_arg (__ap, char *);
1601                         char * __old_value = self->set;
1602                         self->set = g_strdup (set);
1603                         g_free (__old_value);
1604                         break;
1605                 }
1606                 case QUARK_set_STEAL: {
1607                         char * set = va_arg (__ap, char *);
1608                         self->set = set;
1609                         break;
1610                 }
1611                 case QUARK_set_line: {
1612                         int set_line = va_arg (__ap, int);
1613                         self->set_line = set_line;
1614                         break;
1615                 }
1616                 case QUARK_line_no: {
1617                         int line_no = va_arg (__ap, int);
1618                         self->line_no = line_no;
1619                         break;
1620                 }
1621                 default:
1622                         g_warning ("Argument named 'Property::%s' does not exist", arg);
1623                         break;
1624                 }
1625         }
1626 }
1627
1628 static void
1629 setv_type (Type * self, va_list __ap)
1630 {
1631         int quark;
1632         const char *arg;
1633         ensure_quarks ();
1634         while ((arg = va_arg (__ap, char *)) != NULL) {
1635                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1636                 switch (quark) {
1637                 case QUARK_name: {
1638                         char * name = va_arg (__ap, char *);
1639                         char * __old_value = self->name;
1640                         self->name = g_strdup (name);
1641                         g_free (__old_value);
1642                         break;
1643                 }
1644                 case QUARK_name_STEAL: {
1645                         char * name = va_arg (__ap, char *);
1646                         self->name = name;
1647                         break;
1648                 }
1649                 case QUARK_pointer: {
1650                         char * pointer = va_arg (__ap, char *);
1651                         char * __old_value = self->pointer;
1652                         self->pointer = g_strdup (pointer);
1653                         g_free (__old_value);
1654                         break;
1655                 }
1656                 case QUARK_pointer_STEAL: {
1657                         char * pointer = va_arg (__ap, char *);
1658                         self->pointer = pointer;
1659                         break;
1660                 }
1661                 case QUARK_postfix: {
1662                         char * postfix = va_arg (__ap, char *);
1663                         char * __old_value = self->postfix;
1664                         self->postfix = g_strdup (postfix);
1665                         g_free (__old_value);
1666                         break;
1667                 }
1668                 case QUARK_postfix_STEAL: {
1669                         char * postfix = va_arg (__ap, char *);
1670                         self->postfix = postfix;
1671                         break;
1672                 }
1673                 default:
1674                         g_warning ("Argument named 'Type::%s' does not exist", arg);
1675                         break;
1676                 }
1677         }
1678 }
1679
1680 static void
1681 setv_variable (Variable * self, va_list __ap)
1682 {
1683         int quark;
1684         const char *arg;
1685         ensure_quarks ();
1686         while ((arg = va_arg (__ap, char *)) != NULL) {
1687                 quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
1688                 switch (quark) {
1689                 case QUARK_scope: {
1690                         int scope = va_arg (__ap, int);
1691                         self->scope = scope;
1692                         break;
1693                 }
1694                 case QUARK_vtype: {
1695                         Type * vtype = va_arg (__ap, Type *);
1696                         Type * __old_value = self->vtype;
1697                         self->vtype = copy_type (vtype);
1698                         free_type (__old_value);
1699                         break;
1700                 }
1701                 case QUARK_vtype_STEAL: {
1702                         Type * vtype = va_arg (__ap, Type *);
1703                         self->vtype = vtype;
1704                         break;
1705                 }
1706                 case QUARK_glade_widget: {
1707                         gboolean glade_widget = va_arg (__ap, gboolean);
1708                         self->glade_widget = glade_widget;
1709                         break;
1710                 }
1711                 case QUARK_id: {
1712                         char * id = va_arg (__ap, char *);
1713                         char * __old_value = self->id;
1714                         self->id = g_strdup (id);
1715                         g_free (__old_value);
1716                         break;
1717                 }
1718                 case QUARK_id_STEAL: {
1719                         char * id = va_arg (__ap, char *);
1720                         self->id = id;
1721                         break;
1722                 }
1723                 case QUARK_line_no: {
1724                         int line_no = va_arg (__ap, int);
1725                         self->line_no = line_no;
1726                         break;
1727                 }
1728                 case QUARK_destructor_unref: {
1729                         gboolean destructor_unref = va_arg (__ap, gboolean);
1730                         self->destructor_unref = destructor_unref;
1731                         break;
1732                 }
1733                 case QUARK_destructor: {
1734                         char * destructor = va_arg (__ap, char *);
1735                         char * __old_value = self->destructor;
1736                         self->destructor = g_strdup (destructor);
1737                         g_free (__old_value);
1738                         break;
1739                 }
1740                 case QUARK_destructor_STEAL: {
1741                         char * destructor = va_arg (__ap, char *);
1742                         self->destructor = destructor;
1743                         break;
1744                 }
1745                 case QUARK_destructor_line: {
1746                         int destructor_line = va_arg (__ap, int);
1747                         self->destructor_line = destructor_line;
1748                         break;
1749                 }
1750                 case QUARK_destructor_simple: {
1751                         gboolean destructor_simple = va_arg (__ap, gboolean);
1752                         self->destructor_simple = destructor_simple;
1753                         break;
1754                 }
1755                 case QUARK_initializer: {
1756                         char * initializer = va_arg (__ap, char *);
1757                         char * __old_value = self->initializer;
1758                         self->initializer = g_strdup (initializer);
1759                         g_free (__old_value);
1760                         break;
1761                 }
1762                 case QUARK_initializer_STEAL: {
1763                         char * initializer = va_arg (__ap, char *);
1764                         self->initializer = initializer;
1765                         break;
1766                 }
1767                 case QUARK_initializer_line: {
1768                         int initializer_line = va_arg (__ap, int);
1769                         self->initializer_line = initializer_line;
1770                         break;
1771                 }
1772                 case QUARK_initializer_simple: {
1773                         gboolean initializer_simple = va_arg (__ap, gboolean);
1774                         self->initializer_simple = initializer_simple;
1775                         break;
1776                 }
1777                 default:
1778                         g_warning ("Argument named 'Variable::%s' does not exist", arg);
1779                         break;
1780                 }
1781         }
1782 }
1783
1784 Node *
1785 node_copy (Node *node)
1786 {
1787         g_return_val_if_fail (node != NULL, NULL);
1788         g_return_val_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE, NULL);
1789         switch (node->type) {
1790         case ARGUMENT_NODE: return (Node *)copy_argument ((Argument *)node);
1791         case CCODE_NODE: return (Node *)copy_ccode ((CCode *)node);
1792         case CHECK_NODE: return (Node *)copy_check ((Check *)node);
1793         case CLASS_NODE: return (Node *)copy_class ((Class *)node);
1794         case ENUMDEF_NODE: return (Node *)copy_enumdef ((EnumDef *)node);
1795         case ENUMVALUE_NODE: return (Node *)copy_enumvalue ((EnumValue *)node);
1796         case ERROR_NODE: return (Node *)copy_error ((Error *)node);
1797         case FLAGS_NODE: return (Node *)copy_flags ((Flags *)node);
1798         case FUNCARG_NODE: return (Node *)copy_funcarg ((FuncArg *)node);
1799         case METHOD_NODE: return (Node *)copy_method ((Method *)node);
1800         case PROPERTY_NODE: return (Node *)copy_property ((Property *)node);
1801         case TYPE_NODE: return (Node *)copy_type ((Type *)node);
1802         case VARIABLE_NODE: return (Node *)copy_variable ((Variable *)node);
1803         default: return NULL;
1804         }
1805 }
1806
1807 static void
1808 node_setv (Node *node, va_list __ap)
1809 {
1810         g_return_if_fail (node != NULL);
1811         g_return_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE);
1812         switch (node->type) {
1813         case ARGUMENT_NODE: setv_argument ((Argument *)node, __ap); break;
1814         case CCODE_NODE: setv_ccode ((CCode *)node, __ap); break;
1815         case CHECK_NODE: setv_check ((Check *)node, __ap); break;
1816         case CLASS_NODE: setv_class ((Class *)node, __ap); break;
1817         case ENUMDEF_NODE: setv_enumdef ((EnumDef *)node, __ap); break;
1818         case ENUMVALUE_NODE: setv_enumvalue ((EnumValue *)node, __ap); break;
1819         case ERROR_NODE: setv_error ((Error *)node, __ap); break;
1820         case FLAGS_NODE: setv_flags ((Flags *)node, __ap); break;
1821         case FUNCARG_NODE: setv_funcarg ((FuncArg *)node, __ap); break;
1822         case METHOD_NODE: setv_method ((Method *)node, __ap); break;
1823         case PROPERTY_NODE: setv_property ((Property *)node, __ap); break;
1824         case TYPE_NODE: setv_type ((Type *)node, __ap); break;
1825         case VARIABLE_NODE: setv_variable ((Variable *)node, __ap); break;
1826         default: break;
1827         }
1828 }
1829
1830 void
1831 node_set (Node *node, ...)
1832 {
1833         va_list __ap;
1834         va_start (__ap, node);
1835         node_setv (node, __ap);
1836         va_end (__ap);
1837 }
1838
1839 Node *
1840 node_new (NodeType type, ...)
1841 {
1842         va_list __ap;
1843         Node *node = NULL;
1844         va_start (__ap, type);
1845         g_return_val_if_fail (type >= 0 && type < LAST_NODE_TYPE, NULL);
1846         switch (type) {
1847         case ARGUMENT_NODE:
1848                 node = (Node *)g_new0 (Argument, 1);
1849                 node->type = type;
1850                 setv_argument ((Argument *)node, __ap);
1851                 break;
1852         case CCODE_NODE:
1853                 node = (Node *)g_new0 (CCode, 1);
1854                 node->type = type;
1855                 setv_ccode ((CCode *)node, __ap);
1856                 break;
1857         case CHECK_NODE:
1858                 node = (Node *)g_new0 (Check, 1);
1859                 node->type = type;
1860                 setv_check ((Check *)node, __ap);
1861                 break;
1862         case CLASS_NODE:
1863                 node = (Node *)g_new0 (Class, 1);
1864                 node->type = type;
1865                 setv_class ((Class *)node, __ap);
1866                 break;
1867         case ENUMDEF_NODE:
1868                 node = (Node *)g_new0 (EnumDef, 1);
1869                 node->type = type;
1870                 setv_enumdef ((EnumDef *)node, __ap);
1871                 break;
1872         case ENUMVALUE_NODE:
1873                 node = (Node *)g_new0 (EnumValue, 1);
1874                 node->type = type;
1875                 setv_enumvalue ((EnumValue *)node, __ap);
1876                 break;
1877         case ERROR_NODE:
1878                 node = (Node *)g_new0 (Error, 1);
1879                 node->type = type;
1880                 setv_error ((Error *)node, __ap);
1881                 break;
1882         case FLAGS_NODE:
1883                 node = (Node *)g_new0 (Flags, 1);
1884                 node->type = type;
1885                 setv_flags ((Flags *)node, __ap);
1886                 break;
1887         case FUNCARG_NODE:
1888                 node = (Node *)g_new0 (FuncArg, 1);
1889                 node->type = type;
1890                 setv_funcarg ((FuncArg *)node, __ap);
1891                 break;
1892         case METHOD_NODE:
1893                 node = (Node *)g_new0 (Method, 1);
1894                 node->type = type;
1895                 setv_method ((Method *)node, __ap);
1896                 break;
1897         case PROPERTY_NODE:
1898                 node = (Node *)g_new0 (Property, 1);
1899                 node->type = type;
1900                 setv_property ((Property *)node, __ap);
1901                 break;
1902         case TYPE_NODE:
1903                 node = (Node *)g_new0 (Type, 1);
1904                 node->type = type;
1905                 setv_type ((Type *)node, __ap);
1906                 break;
1907         case VARIABLE_NODE:
1908                 node = (Node *)g_new0 (Variable, 1);
1909                 node->type = type;
1910                 setv_variable ((Variable *)node, __ap);
1911                 break;
1912         default: break;
1913         }
1914         va_end (__ap);
1915         return node;
1916 }
1917
1918 void
1919 node_free (Node *node)
1920 {
1921         g_return_if_fail (node != NULL);
1922         g_return_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE);
1923         switch (node->type) {
1924         case ARGUMENT_NODE: free_argument ((Argument *)node); return;
1925         case CCODE_NODE: free_ccode ((CCode *)node); return;
1926         case CHECK_NODE: free_check ((Check *)node); return;
1927         case CLASS_NODE: free_class ((Class *)node); return;
1928         case ENUMDEF_NODE: free_enumdef ((EnumDef *)node); return;
1929         case ENUMVALUE_NODE: free_enumvalue ((EnumValue *)node); return;
1930         case ERROR_NODE: free_error ((Error *)node); return;
1931         case FLAGS_NODE: free_flags ((Flags *)node); return;
1932         case FUNCARG_NODE: free_funcarg ((FuncArg *)node); return;
1933         case METHOD_NODE: free_method ((Method *)node); return;
1934         case PROPERTY_NODE: free_property ((Property *)node); return;
1935         case TYPE_NODE: free_type ((Type *)node); return;
1936         case VARIABLE_NODE: free_variable ((Variable *)node); return;
1937         default: return;
1938         }
1939 }
1940
1941 GList *
1942 node_list_copy (GList *nodes)
1943 {
1944         GList *li;
1945         nodes = g_list_copy (nodes);
1946         for (li = nodes; li != NULL; li = li->next) {
1947                 li->data = node_copy (li->data);
1948         }
1949         return nodes;
1950 }
1951
1952 void
1953 node_list_free (GList *nodes)
1954 {
1955         GList *li;
1956         for (li = nodes; li != NULL; li = li->next) {
1957                 node_free (li->data);
1958         }
1959         g_list_free (nodes);
1960 }
1961