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