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