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