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