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