* Do not edit by hand! */
#include <glib.h>
+#include <stdarg.h>
#include "treefuncs.h"
-#define COPY_LIST_VALS(list,func) { GList *li; for(li=(list);li;li=li->next) { li->data=func(li->data); } }
-
-Node * new_argument (char * gtktype, Type * atype, GList * flags, char * name, char * get, int get_line, char * set, int set_line, int line_no)
-{
- Argument * self = g_new0(Argument, 1);
- self->type = ARGUMENT_NODE;
- self->gtktype = gtktype;
- self->atype = atype;
- self->flags = flags;
- self->name = name;
- self->get = get;
- self->get_line = get_line;
- self->set = set;
- self->set_line = set_line;
- self->line_no = line_no;
- return (Node *)self;
-}
+#define COPY_LIST_VALS(list,func) { GList *li; for (li=(list);li;li=li->next) { li->data=func (li->data); } }
-Node * new_ccode (int cctype, char * cbuf, int line_no)
-{
- CCode * self = g_new0(CCode, 1);
- self->type = CCODE_NODE;
- self->cctype = cctype;
- self->cbuf = cbuf;
- self->line_no = line_no;
- return (Node *)self;
-}
+static Argument *
+copy_argument (Argument * self);
+static CCode *
+copy_ccode (CCode * self);
+static Check *
+copy_check (Check * self);
+static Class *
+copy_class (Class * self);
+static FuncArg *
+copy_funcarg (FuncArg * self);
+static Method *
+copy_method (Method * self);
+static Property *
+copy_property (Property * self);
+static Type *
+copy_type (Type * self);
+static Variable *
+copy_variable (Variable * self);
-Node * new_check (int chtype, char * number)
-{
- Check * self = g_new0(Check, 1);
- self->type = CHECK_NODE;
- self->chtype = chtype;
- self->number = number;
- return (Node *)self;
-}
+void
+free_argument (Argument * self);
+void
+free_ccode (CCode * self);
+void
+free_check (Check * self);
+void
+free_class (Class * self);
+void
+free_funcarg (FuncArg * self);
+void
+free_method (Method * self);
+void
+free_property (Property * self);
+void
+free_type (Type * self);
+void
+free_variable (Variable * self);
-Node * new_class (char * otype, char * ptype, char * chunk_size, GList * nodes)
-{
- Class * self = g_new0(Class, 1);
- self->type = CLASS_NODE;
- self->otype = otype;
- self->ptype = ptype;
- self->chunk_size = chunk_size;
- self->nodes = nodes;
- return (Node *)self;
-}
-
-Node * new_funcarg (Type * atype, char * name, GList * checks)
-{
- FuncArg * self = g_new0(FuncArg, 1);
- self->type = FUNCARG_NODE;
- self->atype = atype;
- self->name = name;
- self->checks = checks;
- return (Node *)self;
-}
+static void
+setv_argument (Argument * self, va_list __ap);
+static void
+setv_ccode (CCode * self, va_list __ap);
+static void
+setv_check (Check * self, va_list __ap);
+static void
+setv_class (Class * self, va_list __ap);
+static void
+setv_funcarg (FuncArg * self, va_list __ap);
+static void
+setv_method (Method * self, va_list __ap);
+static void
+setv_property (Property * self, va_list __ap);
+static void
+setv_type (Type * self, va_list __ap);
+static void
+setv_variable (Variable * self, va_list __ap);
-Node * new_method (int scope, int method, Type * mtype, char * otype, GList * gtktypes, GList * flags, char * id, GList * args, char * onerror, char * defreturn, char * cbuf, int line_no, int ccode_line, gboolean vararg, int unique_id)
-{
- Method * self = g_new0(Method, 1);
- self->type = METHOD_NODE;
- self->scope = scope;
- self->method = method;
- self->mtype = mtype;
- self->otype = otype;
- self->gtktypes = gtktypes;
- self->flags = flags;
- self->id = id;
- self->args = args;
- self->onerror = onerror;
- self->defreturn = defreturn;
- self->cbuf = cbuf;
- self->line_no = line_no;
- self->ccode_line = ccode_line;
- self->vararg = vararg;
- self->unique_id = unique_id;
- return (Node *)self;
-}
+static gboolean quarks_set_up = FALSE;
+static GHashTable *quark_ht;
+enum {
+ QUARK_0,
+ QUARK_otype,
+ QUARK_otype_STEAL,
+ QUARK_ptype,
+ QUARK_ptype_STEAL,
+ QUARK_bonobo_x_class,
+ QUARK_bonobo_x_class_STEAL,
+ QUARK_chunk_size,
+ QUARK_chunk_size_STEAL,
+ QUARK_nodes,
+ QUARK_nodes_STEAL,
+ QUARK_name,
+ QUARK_name_STEAL,
+ QUARK_pointer,
+ QUARK_pointer_STEAL,
+ QUARK_postfix,
+ QUARK_postfix_STEAL,
+ QUARK_cctype,
+ QUARK_cbuf,
+ QUARK_cbuf_STEAL,
+ QUARK_line_no,
+ QUARK_chtype,
+ QUARK_number,
+ QUARK_number_STEAL,
+ QUARK_atype,
+ QUARK_atype_STEAL,
+ QUARK_checks,
+ QUARK_checks_STEAL,
+ QUARK_gtktype,
+ QUARK_gtktype_STEAL,
+ QUARK_flags,
+ QUARK_flags_STEAL,
+ QUARK_get,
+ QUARK_get_STEAL,
+ QUARK_get_line,
+ QUARK_set,
+ QUARK_set_STEAL,
+ QUARK_set_line,
+ QUARK_nick,
+ QUARK_nick_STEAL,
+ QUARK_blurb,
+ QUARK_blurb_STEAL,
+ QUARK_minimum,
+ QUARK_minimum_STEAL,
+ QUARK_maximum,
+ QUARK_maximum_STEAL,
+ QUARK_default_value,
+ QUARK_default_value_STEAL,
+ QUARK_extra_gtktype,
+ QUARK_extra_gtktype_STEAL,
+ QUARK_link,
+ QUARK_export,
+ QUARK_scope,
+ QUARK_method,
+ QUARK_mtype,
+ QUARK_mtype_STEAL,
+ QUARK_gtktypes,
+ QUARK_gtktypes_STEAL,
+ QUARK_id,
+ QUARK_id_STEAL,
+ QUARK_args,
+ QUARK_args_STEAL,
+ QUARK_onerror,
+ QUARK_onerror_STEAL,
+ QUARK_defreturn,
+ QUARK_defreturn_STEAL,
+ QUARK_ccode_line,
+ QUARK_vararg,
+ QUARK_unique_id,
+ QUARK_bonobo_x_func,
+ QUARK_vtype,
+ QUARK_vtype_STEAL,
+ QUARK_destructor_unref,
+ QUARK_destructor,
+ QUARK_destructor_STEAL,
+ QUARK_destructor_line,
+ QUARK_destructor_simple,
+ QUARK_initializer,
+ QUARK_initializer_STEAL,
+ QUARK_initializer_line,
+ QUARK_LAST
+};
-Node * new_type (char * name, char * pointer, char * postfix)
+static void
+ensure_quarks (void)
{
- Type * self = g_new0(Type, 1);
- self->type = TYPE_NODE;
- self->name = name;
- self->pointer = pointer;
- self->postfix = postfix;
- return (Node *)self;
+ if (quarks_set_up)
+ return;
+ quark_ht = g_hash_table_new (g_str_hash, g_str_equal);
+ quarks_set_up = TRUE;
+ g_hash_table_insert (quark_ht, "otype", GINT_TO_POINTER (QUARK_otype));
+ g_hash_table_insert (quark_ht, "otype:steal", GINT_TO_POINTER (QUARK_otype_STEAL));
+ g_hash_table_insert (quark_ht, "ptype", GINT_TO_POINTER (QUARK_ptype));
+ g_hash_table_insert (quark_ht, "ptype:steal", GINT_TO_POINTER (QUARK_ptype_STEAL));
+ g_hash_table_insert (quark_ht, "bonobo_x_class", GINT_TO_POINTER (QUARK_bonobo_x_class));
+ g_hash_table_insert (quark_ht, "bonobo_x_class:steal", GINT_TO_POINTER (QUARK_bonobo_x_class_STEAL));
+ g_hash_table_insert (quark_ht, "chunk_size", GINT_TO_POINTER (QUARK_chunk_size));
+ g_hash_table_insert (quark_ht, "chunk_size:steal", GINT_TO_POINTER (QUARK_chunk_size_STEAL));
+ g_hash_table_insert (quark_ht, "nodes", GINT_TO_POINTER (QUARK_nodes));
+ g_hash_table_insert (quark_ht, "nodes:steal", GINT_TO_POINTER (QUARK_nodes_STEAL));
+ g_hash_table_insert (quark_ht, "name", GINT_TO_POINTER (QUARK_name));
+ g_hash_table_insert (quark_ht, "name:steal", GINT_TO_POINTER (QUARK_name_STEAL));
+ g_hash_table_insert (quark_ht, "pointer", GINT_TO_POINTER (QUARK_pointer));
+ g_hash_table_insert (quark_ht, "pointer:steal", GINT_TO_POINTER (QUARK_pointer_STEAL));
+ g_hash_table_insert (quark_ht, "postfix", GINT_TO_POINTER (QUARK_postfix));
+ g_hash_table_insert (quark_ht, "postfix:steal", GINT_TO_POINTER (QUARK_postfix_STEAL));
+ g_hash_table_insert (quark_ht, "cctype", GINT_TO_POINTER (QUARK_cctype));
+ g_hash_table_insert (quark_ht, "cbuf", GINT_TO_POINTER (QUARK_cbuf));
+ g_hash_table_insert (quark_ht, "cbuf:steal", GINT_TO_POINTER (QUARK_cbuf_STEAL));
+ g_hash_table_insert (quark_ht, "line_no", GINT_TO_POINTER (QUARK_line_no));
+ g_hash_table_insert (quark_ht, "chtype", GINT_TO_POINTER (QUARK_chtype));
+ g_hash_table_insert (quark_ht, "number", GINT_TO_POINTER (QUARK_number));
+ g_hash_table_insert (quark_ht, "number:steal", GINT_TO_POINTER (QUARK_number_STEAL));
+ g_hash_table_insert (quark_ht, "atype", GINT_TO_POINTER (QUARK_atype));
+ g_hash_table_insert (quark_ht, "atype:steal", GINT_TO_POINTER (QUARK_atype_STEAL));
+ g_hash_table_insert (quark_ht, "checks", GINT_TO_POINTER (QUARK_checks));
+ g_hash_table_insert (quark_ht, "checks:steal", GINT_TO_POINTER (QUARK_checks_STEAL));
+ g_hash_table_insert (quark_ht, "gtktype", GINT_TO_POINTER (QUARK_gtktype));
+ g_hash_table_insert (quark_ht, "gtktype:steal", GINT_TO_POINTER (QUARK_gtktype_STEAL));
+ g_hash_table_insert (quark_ht, "flags", GINT_TO_POINTER (QUARK_flags));
+ g_hash_table_insert (quark_ht, "flags:steal", GINT_TO_POINTER (QUARK_flags_STEAL));
+ g_hash_table_insert (quark_ht, "get", GINT_TO_POINTER (QUARK_get));
+ g_hash_table_insert (quark_ht, "get:steal", GINT_TO_POINTER (QUARK_get_STEAL));
+ g_hash_table_insert (quark_ht, "get_line", GINT_TO_POINTER (QUARK_get_line));
+ g_hash_table_insert (quark_ht, "set", GINT_TO_POINTER (QUARK_set));
+ g_hash_table_insert (quark_ht, "set:steal", GINT_TO_POINTER (QUARK_set_STEAL));
+ g_hash_table_insert (quark_ht, "set_line", GINT_TO_POINTER (QUARK_set_line));
+ g_hash_table_insert (quark_ht, "nick", GINT_TO_POINTER (QUARK_nick));
+ g_hash_table_insert (quark_ht, "nick:steal", GINT_TO_POINTER (QUARK_nick_STEAL));
+ g_hash_table_insert (quark_ht, "blurb", GINT_TO_POINTER (QUARK_blurb));
+ g_hash_table_insert (quark_ht, "blurb:steal", GINT_TO_POINTER (QUARK_blurb_STEAL));
+ g_hash_table_insert (quark_ht, "minimum", GINT_TO_POINTER (QUARK_minimum));
+ g_hash_table_insert (quark_ht, "minimum:steal", GINT_TO_POINTER (QUARK_minimum_STEAL));
+ g_hash_table_insert (quark_ht, "maximum", GINT_TO_POINTER (QUARK_maximum));
+ g_hash_table_insert (quark_ht, "maximum:steal", GINT_TO_POINTER (QUARK_maximum_STEAL));
+ g_hash_table_insert (quark_ht, "default_value", GINT_TO_POINTER (QUARK_default_value));
+ g_hash_table_insert (quark_ht, "default_value:steal", GINT_TO_POINTER (QUARK_default_value_STEAL));
+ g_hash_table_insert (quark_ht, "extra_gtktype", GINT_TO_POINTER (QUARK_extra_gtktype));
+ g_hash_table_insert (quark_ht, "extra_gtktype:steal", GINT_TO_POINTER (QUARK_extra_gtktype_STEAL));
+ g_hash_table_insert (quark_ht, "link", GINT_TO_POINTER (QUARK_link));
+ g_hash_table_insert (quark_ht, "export", GINT_TO_POINTER (QUARK_export));
+ g_hash_table_insert (quark_ht, "scope", GINT_TO_POINTER (QUARK_scope));
+ g_hash_table_insert (quark_ht, "method", GINT_TO_POINTER (QUARK_method));
+ g_hash_table_insert (quark_ht, "mtype", GINT_TO_POINTER (QUARK_mtype));
+ g_hash_table_insert (quark_ht, "mtype:steal", GINT_TO_POINTER (QUARK_mtype_STEAL));
+ g_hash_table_insert (quark_ht, "gtktypes", GINT_TO_POINTER (QUARK_gtktypes));
+ g_hash_table_insert (quark_ht, "gtktypes:steal", GINT_TO_POINTER (QUARK_gtktypes_STEAL));
+ g_hash_table_insert (quark_ht, "id", GINT_TO_POINTER (QUARK_id));
+ g_hash_table_insert (quark_ht, "id:steal", GINT_TO_POINTER (QUARK_id_STEAL));
+ g_hash_table_insert (quark_ht, "args", GINT_TO_POINTER (QUARK_args));
+ g_hash_table_insert (quark_ht, "args:steal", GINT_TO_POINTER (QUARK_args_STEAL));
+ g_hash_table_insert (quark_ht, "onerror", GINT_TO_POINTER (QUARK_onerror));
+ g_hash_table_insert (quark_ht, "onerror:steal", GINT_TO_POINTER (QUARK_onerror_STEAL));
+ g_hash_table_insert (quark_ht, "defreturn", GINT_TO_POINTER (QUARK_defreturn));
+ g_hash_table_insert (quark_ht, "defreturn:steal", GINT_TO_POINTER (QUARK_defreturn_STEAL));
+ g_hash_table_insert (quark_ht, "ccode_line", GINT_TO_POINTER (QUARK_ccode_line));
+ g_hash_table_insert (quark_ht, "vararg", GINT_TO_POINTER (QUARK_vararg));
+ g_hash_table_insert (quark_ht, "unique_id", GINT_TO_POINTER (QUARK_unique_id));
+ g_hash_table_insert (quark_ht, "bonobo_x_func", GINT_TO_POINTER (QUARK_bonobo_x_func));
+ g_hash_table_insert (quark_ht, "vtype", GINT_TO_POINTER (QUARK_vtype));
+ g_hash_table_insert (quark_ht, "vtype:steal", GINT_TO_POINTER (QUARK_vtype_STEAL));
+ g_hash_table_insert (quark_ht, "destructor_unref", GINT_TO_POINTER (QUARK_destructor_unref));
+ g_hash_table_insert (quark_ht, "destructor", GINT_TO_POINTER (QUARK_destructor));
+ g_hash_table_insert (quark_ht, "destructor:steal", GINT_TO_POINTER (QUARK_destructor_STEAL));
+ g_hash_table_insert (quark_ht, "destructor_line", GINT_TO_POINTER (QUARK_destructor_line));
+ g_hash_table_insert (quark_ht, "destructor_simple", GINT_TO_POINTER (QUARK_destructor_simple));
+ g_hash_table_insert (quark_ht, "initializer", GINT_TO_POINTER (QUARK_initializer));
+ g_hash_table_insert (quark_ht, "initializer:steal", GINT_TO_POINTER (QUARK_initializer_STEAL));
+ g_hash_table_insert (quark_ht, "initializer_line", GINT_TO_POINTER (QUARK_initializer_line));
}
-Node * new_variable (int scope, Type * vtype, char * id, int line_no, char * destructor, int destructor_line, gboolean destructor_simple, char * initializer, int initializer_line)
-{
- Variable * self = g_new0(Variable, 1);
- self->type = VARIABLE_NODE;
- self->scope = scope;
- self->vtype = vtype;
- self->id = id;
- self->line_no = line_no;
- self->destructor = destructor;
- self->destructor_line = destructor_line;
- self->destructor_simple = destructor_simple;
- self->initializer = initializer;
- self->initializer_line = initializer_line;
- return (Node *)self;
-}
-
-Argument * copy_argument (Argument * self)
+static Argument *
+copy_argument (Argument * self)
{
Argument * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == ARGUMENT_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == ARGUMENT_NODE, NULL);
new = g_new0(Argument, 1);
new->type = ARGUMENT_NODE;
- new->gtktype = g_strdup(self->gtktype);
- new->atype = copy_type(self->atype);
- new->flags = g_list_copy(self->flags); COPY_LIST_VALS(new->flags, g_strdup);
- new->name = g_strdup(self->name);
- new->get = g_strdup(self->get);
+ new->gtktype = g_strdup (self->gtktype);
+ new->atype = copy_type (self->atype);
+ new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
+ new->name = g_strdup (self->name);
+ new->get = g_strdup (self->get);
new->get_line = self->get_line;
- new->set = g_strdup(self->set);
+ new->set = g_strdup (self->set);
new->set_line = self->set_line;
new->line_no = self->line_no;
return new;
}
-CCode * copy_ccode (CCode * self)
+static CCode *
+copy_ccode (CCode * self)
{
CCode * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == CCODE_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == CCODE_NODE, NULL);
new = g_new0(CCode, 1);
new->type = CCODE_NODE;
new->cctype = self->cctype;
- new->cbuf = g_strdup(self->cbuf);
+ new->cbuf = g_strdup (self->cbuf);
new->line_no = self->line_no;
return new;
}
-Check * copy_check (Check * self)
+static Check *
+copy_check (Check * self)
{
Check * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == CHECK_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == CHECK_NODE, NULL);
new = g_new0(Check, 1);
new->type = CHECK_NODE;
new->chtype = self->chtype;
- new->number = g_strdup(self->number);
+ new->number = g_strdup (self->number);
return new;
}
-Class * copy_class (Class * self)
+static Class *
+copy_class (Class * self)
{
Class * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == CLASS_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == CLASS_NODE, NULL);
new = g_new0(Class, 1);
new->type = CLASS_NODE;
- new->otype = g_strdup(self->otype);
- new->ptype = g_strdup(self->ptype);
- new->chunk_size = g_strdup(self->chunk_size);
- new->nodes = copy_node_list(self->nodes);
+ new->otype = g_strdup (self->otype);
+ new->ptype = g_strdup (self->ptype);
+ new->bonobo_x_class = g_strdup (self->bonobo_x_class);
+ new->chunk_size = g_strdup (self->chunk_size);
+ new->nodes = node_list_copy (self->nodes);
return new;
}
-FuncArg * copy_funcarg (FuncArg * self)
+static FuncArg *
+copy_funcarg (FuncArg * self)
{
FuncArg * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == FUNCARG_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == FUNCARG_NODE, NULL);
new = g_new0(FuncArg, 1);
new->type = FUNCARG_NODE;
- new->atype = copy_type(self->atype);
- new->name = g_strdup(self->name);
- new->checks = copy_node_list(self->checks);
+ new->atype = copy_type (self->atype);
+ new->name = g_strdup (self->name);
+ new->checks = node_list_copy (self->checks);
return new;
}
-Method * copy_method (Method * self)
+static Method *
+copy_method (Method * self)
{
Method * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == METHOD_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == METHOD_NODE, NULL);
new = g_new0(Method, 1);
new->type = METHOD_NODE;
new->scope = self->scope;
new->method = self->method;
- new->mtype = copy_type(self->mtype);
- new->otype = g_strdup(self->otype);
- new->gtktypes = g_list_copy(self->gtktypes); COPY_LIST_VALS(new->gtktypes, g_strdup);
- new->flags = g_list_copy(self->flags); COPY_LIST_VALS(new->flags, g_strdup);
- new->id = g_strdup(self->id);
- new->args = copy_node_list(self->args);
- new->onerror = g_strdup(self->onerror);
- new->defreturn = g_strdup(self->defreturn);
- new->cbuf = g_strdup(self->cbuf);
+ new->mtype = copy_type (self->mtype);
+ new->otype = g_strdup (self->otype);
+ new->gtktypes = g_list_copy (self->gtktypes); COPY_LIST_VALS(new->gtktypes, g_strdup);
+ new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
+ new->id = g_strdup (self->id);
+ new->args = node_list_copy (self->args);
+ new->onerror = g_strdup (self->onerror);
+ new->defreturn = g_strdup (self->defreturn);
+ new->cbuf = g_strdup (self->cbuf);
new->line_no = self->line_no;
new->ccode_line = self->ccode_line;
new->vararg = self->vararg;
new->unique_id = self->unique_id;
+ new->bonobo_x_func = self->bonobo_x_func;
return new;
}
-Type * copy_type (Type * self)
+static Property *
+copy_property (Property * self)
+{
+ Property * new;
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == PROPERTY_NODE, NULL);
+ new = g_new0(Property, 1);
+ new->type = PROPERTY_NODE;
+ new->gtktype = g_strdup (self->gtktype);
+ new->ptype = copy_type (self->ptype);
+ new->flags = g_list_copy (self->flags); COPY_LIST_VALS(new->flags, g_strdup);
+ new->name = g_strdup (self->name);
+ new->nick = g_strdup (self->nick);
+ new->blurb = g_strdup (self->blurb);
+ new->minimum = g_strdup (self->minimum);
+ new->maximum = g_strdup (self->maximum);
+ new->default_value = g_strdup (self->default_value);
+ new->extra_gtktype = g_strdup (self->extra_gtktype);
+ new->link = self->link;
+ new->export = self->export;
+ new->get = g_strdup (self->get);
+ new->get_line = self->get_line;
+ new->set = g_strdup (self->set);
+ new->set_line = self->set_line;
+ new->line_no = self->line_no;
+ return new;
+}
+
+static Type *
+copy_type (Type * self)
{
Type * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == TYPE_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == TYPE_NODE, NULL);
new = g_new0(Type, 1);
new->type = TYPE_NODE;
- new->name = g_strdup(self->name);
- new->pointer = g_strdup(self->pointer);
- new->postfix = g_strdup(self->postfix);
+ new->name = g_strdup (self->name);
+ new->pointer = g_strdup (self->pointer);
+ new->postfix = g_strdup (self->postfix);
return new;
}
-Variable * copy_variable (Variable * self)
+static Variable *
+copy_variable (Variable * self)
{
Variable * new;
- g_return_val_if_fail(self != NULL, NULL);
- g_return_val_if_fail(self->type == VARIABLE_NODE, NULL);
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (self->type == VARIABLE_NODE, NULL);
new = g_new0(Variable, 1);
new->type = VARIABLE_NODE;
new->scope = self->scope;
- new->vtype = copy_type(self->vtype);
- new->id = g_strdup(self->id);
+ new->vtype = copy_type (self->vtype);
+ new->id = g_strdup (self->id);
new->line_no = self->line_no;
- new->destructor = g_strdup(self->destructor);
+ new->destructor_unref = self->destructor_unref;
+ new->destructor = g_strdup (self->destructor);
new->destructor_line = self->destructor_line;
new->destructor_simple = self->destructor_simple;
- new->initializer = g_strdup(self->initializer);
+ new->initializer = g_strdup (self->initializer);
new->initializer_line = self->initializer_line;
return new;
}
-void free_argument (Argument * self)
+void
+free_argument (Argument * self)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == ARGUMENT_NODE);
+ g_free (self->gtktype);
+ free_type (self->atype);
+ g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
+ g_free (self->name);
+ g_free (self->get);
+ g_free (self->set);
+ g_free (self);
+}
+
+void
+free_ccode (CCode * self)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == CCODE_NODE);
+ g_free (self->cbuf);
+ g_free (self);
+}
+
+void
+free_check (Check * self)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == CHECK_NODE);
+ g_free (self->number);
+ g_free (self);
+}
+
+void
+free_class (Class * self)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == CLASS_NODE);
+ g_free (self->otype);
+ g_free (self->ptype);
+ g_free (self->bonobo_x_class);
+ g_free (self->chunk_size);
+ node_list_free (self->nodes);
+ g_free (self);
+}
+
+void
+free_funcarg (FuncArg * self)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == FUNCARG_NODE);
+ free_type (self->atype);
+ g_free (self->name);
+ node_list_free (self->checks);
+ g_free (self);
+}
+
+void
+free_method (Method * self)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == ARGUMENT_NODE);
- g_free(self->gtktype);
- free_type(self->atype);
- g_list_foreach(self->flags, (GFunc)g_free, NULL); g_list_free(self->flags);
- g_free(self->name);
- g_free(self->get);
- g_free(self->set);
- g_free(self);
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == METHOD_NODE);
+ free_type (self->mtype);
+ g_free (self->otype);
+ g_list_foreach (self->gtktypes, (GFunc)g_free, NULL); g_list_free (self->gtktypes);
+ g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
+ g_free (self->id);
+ node_list_free (self->args);
+ g_free (self->onerror);
+ g_free (self->defreturn);
+ g_free (self->cbuf);
+ g_free (self);
}
-void free_ccode (CCode * self)
+void
+free_property (Property * self)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == CCODE_NODE);
- g_free(self->cbuf);
- g_free(self);
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == PROPERTY_NODE);
+ g_free (self->gtktype);
+ free_type (self->ptype);
+ g_list_foreach (self->flags, (GFunc)g_free, NULL); g_list_free (self->flags);
+ g_free (self->name);
+ g_free (self->nick);
+ g_free (self->blurb);
+ g_free (self->minimum);
+ g_free (self->maximum);
+ g_free (self->default_value);
+ g_free (self->extra_gtktype);
+ g_free (self->get);
+ g_free (self->set);
+ g_free (self);
}
-void free_check (Check * self)
+void
+free_type (Type * self)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == CHECK_NODE);
- g_free(self->number);
- g_free(self);
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == TYPE_NODE);
+ g_free (self->name);
+ g_free (self->pointer);
+ g_free (self->postfix);
+ g_free (self);
}
-void free_class (Class * self)
+void
+free_variable (Variable * self)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == CLASS_NODE);
- g_free(self->otype);
- g_free(self->ptype);
- g_free(self->chunk_size);
- free_node_list(self->nodes);
- g_free(self);
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->type == VARIABLE_NODE);
+ free_type (self->vtype);
+ g_free (self->id);
+ g_free (self->destructor);
+ g_free (self->initializer);
+ g_free (self);
}
-void free_funcarg (FuncArg * self)
+static void
+setv_argument (Argument * self, va_list __ap)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == FUNCARG_NODE);
- free_type(self->atype);
- g_free(self->name);
- free_node_list(self->checks);
- g_free(self);
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_gtktype: {
+ char * gtktype = va_arg (__ap, char *);
+ char * __old_value = self->gtktype;
+ self->gtktype = g_strdup (gtktype);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_gtktype_STEAL: {
+ char * gtktype = va_arg (__ap, char *);
+ self->gtktype = gtktype;
+ break;
+ }
+ case QUARK_atype: {
+ Type * atype = va_arg (__ap, Type *);
+ Type * __old_value = self->atype;
+ self->atype = copy_type (atype);
+ free_type (__old_value);
+ break;
+ }
+ case QUARK_atype_STEAL: {
+ Type * atype = va_arg (__ap, Type *);
+ self->atype = atype;
+ break;
+ }
+ case QUARK_flags: {
+ GList * flags = va_arg (__ap, GList *);
+ GList * __old_value = self->flags;
+ self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
+ g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
+ break;
+ }
+ case QUARK_flags_STEAL: {
+ GList * flags = va_arg (__ap, GList *);
+ self->flags = flags;
+ break;
+ }
+ case QUARK_name: {
+ char * name = va_arg (__ap, char *);
+ char * __old_value = self->name;
+ self->name = g_strdup (name);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_name_STEAL: {
+ char * name = va_arg (__ap, char *);
+ self->name = name;
+ break;
+ }
+ case QUARK_get: {
+ char * get = va_arg (__ap, char *);
+ char * __old_value = self->get;
+ self->get = g_strdup (get);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_get_STEAL: {
+ char * get = va_arg (__ap, char *);
+ self->get = get;
+ break;
+ }
+ case QUARK_get_line: {
+ int get_line = va_arg (__ap, int);
+ self->get_line = get_line;
+ break;
+ }
+ case QUARK_set: {
+ char * set = va_arg (__ap, char *);
+ char * __old_value = self->set;
+ self->set = g_strdup (set);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_set_STEAL: {
+ char * set = va_arg (__ap, char *);
+ self->set = set;
+ break;
+ }
+ case QUARK_set_line: {
+ int set_line = va_arg (__ap, int);
+ self->set_line = set_line;
+ break;
+ }
+ case QUARK_line_no: {
+ int line_no = va_arg (__ap, int);
+ self->line_no = line_no;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Argument::%s' does not exist", arg);
+ break;
+ }
+ }
+}
+
+static void
+setv_ccode (CCode * self, va_list __ap)
+{
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_cctype: {
+ int cctype = va_arg (__ap, int);
+ self->cctype = cctype;
+ break;
+ }
+ case QUARK_cbuf: {
+ char * cbuf = va_arg (__ap, char *);
+ char * __old_value = self->cbuf;
+ self->cbuf = g_strdup (cbuf);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_cbuf_STEAL: {
+ char * cbuf = va_arg (__ap, char *);
+ self->cbuf = cbuf;
+ break;
+ }
+ case QUARK_line_no: {
+ int line_no = va_arg (__ap, int);
+ self->line_no = line_no;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'CCode::%s' does not exist", arg);
+ break;
+ }
+ }
+}
+
+static void
+setv_check (Check * self, va_list __ap)
+{
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_chtype: {
+ int chtype = va_arg (__ap, int);
+ self->chtype = chtype;
+ break;
+ }
+ case QUARK_number: {
+ char * number = va_arg (__ap, char *);
+ char * __old_value = self->number;
+ self->number = g_strdup (number);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_number_STEAL: {
+ char * number = va_arg (__ap, char *);
+ self->number = number;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Check::%s' does not exist", arg);
+ break;
+ }
+ }
}
-void free_method (Method * self)
+static void
+setv_class (Class * self, va_list __ap)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == METHOD_NODE);
- free_type(self->mtype);
- g_free(self->otype);
- g_list_foreach(self->gtktypes, (GFunc)g_free, NULL); g_list_free(self->gtktypes);
- g_list_foreach(self->flags, (GFunc)g_free, NULL); g_list_free(self->flags);
- g_free(self->id);
- free_node_list(self->args);
- g_free(self->onerror);
- g_free(self->defreturn);
- g_free(self->cbuf);
- g_free(self);
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_otype: {
+ char * otype = va_arg (__ap, char *);
+ char * __old_value = self->otype;
+ self->otype = g_strdup (otype);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_otype_STEAL: {
+ char * otype = va_arg (__ap, char *);
+ self->otype = otype;
+ break;
+ }
+ case QUARK_ptype: {
+ char * ptype = va_arg (__ap, char *);
+ char * __old_value = self->ptype;
+ self->ptype = g_strdup (ptype);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_ptype_STEAL: {
+ char * ptype = va_arg (__ap, char *);
+ self->ptype = ptype;
+ break;
+ }
+ case QUARK_bonobo_x_class: {
+ char * bonobo_x_class = va_arg (__ap, char *);
+ char * __old_value = self->bonobo_x_class;
+ self->bonobo_x_class = g_strdup (bonobo_x_class);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_bonobo_x_class_STEAL: {
+ char * bonobo_x_class = va_arg (__ap, char *);
+ self->bonobo_x_class = bonobo_x_class;
+ break;
+ }
+ case QUARK_chunk_size: {
+ char * chunk_size = va_arg (__ap, char *);
+ char * __old_value = self->chunk_size;
+ self->chunk_size = g_strdup (chunk_size);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_chunk_size_STEAL: {
+ char * chunk_size = va_arg (__ap, char *);
+ self->chunk_size = chunk_size;
+ break;
+ }
+ case QUARK_nodes: {
+ GList * nodes = va_arg (__ap, GList *);
+ GList * __old_value = self->nodes;
+ self->nodes = node_list_copy (nodes);
+ node_list_free (__old_value);
+ break;
+ }
+ case QUARK_nodes_STEAL: {
+ GList * nodes = va_arg (__ap, GList *);
+ self->nodes = nodes;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Class::%s' does not exist", arg);
+ break;
+ }
+ }
}
-void free_type (Type * self)
+static void
+setv_funcarg (FuncArg * self, va_list __ap)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == TYPE_NODE);
- g_free(self->name);
- g_free(self->pointer);
- g_free(self->postfix);
- g_free(self);
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_atype: {
+ Type * atype = va_arg (__ap, Type *);
+ Type * __old_value = self->atype;
+ self->atype = copy_type (atype);
+ free_type (__old_value);
+ break;
+ }
+ case QUARK_atype_STEAL: {
+ Type * atype = va_arg (__ap, Type *);
+ self->atype = atype;
+ break;
+ }
+ case QUARK_name: {
+ char * name = va_arg (__ap, char *);
+ char * __old_value = self->name;
+ self->name = g_strdup (name);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_name_STEAL: {
+ char * name = va_arg (__ap, char *);
+ self->name = name;
+ break;
+ }
+ case QUARK_checks: {
+ GList * checks = va_arg (__ap, GList *);
+ GList * __old_value = self->checks;
+ self->checks = node_list_copy (checks);
+ node_list_free (__old_value);
+ break;
+ }
+ case QUARK_checks_STEAL: {
+ GList * checks = va_arg (__ap, GList *);
+ self->checks = checks;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'FuncArg::%s' does not exist", arg);
+ break;
+ }
+ }
}
-void free_variable (Variable * self)
+static void
+setv_method (Method * self, va_list __ap)
{
- g_return_if_fail(self != NULL);
- g_return_if_fail(self->type == VARIABLE_NODE);
- free_type(self->vtype);
- g_free(self->id);
- g_free(self->destructor);
- g_free(self->initializer);
- g_free(self);
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_scope: {
+ int scope = va_arg (__ap, int);
+ self->scope = scope;
+ break;
+ }
+ case QUARK_method: {
+ int method = va_arg (__ap, int);
+ self->method = method;
+ break;
+ }
+ case QUARK_mtype: {
+ Type * mtype = va_arg (__ap, Type *);
+ Type * __old_value = self->mtype;
+ self->mtype = copy_type (mtype);
+ free_type (__old_value);
+ break;
+ }
+ case QUARK_mtype_STEAL: {
+ Type * mtype = va_arg (__ap, Type *);
+ self->mtype = mtype;
+ break;
+ }
+ case QUARK_otype: {
+ char * otype = va_arg (__ap, char *);
+ char * __old_value = self->otype;
+ self->otype = g_strdup (otype);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_otype_STEAL: {
+ char * otype = va_arg (__ap, char *);
+ self->otype = otype;
+ break;
+ }
+ case QUARK_gtktypes: {
+ GList * gtktypes = va_arg (__ap, GList *);
+ GList * __old_value = self->gtktypes;
+ self->gtktypes = g_list_copy (gtktypes); COPY_LIST_VALS(self->gtktypes, g_strdup);
+ g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
+ break;
+ }
+ case QUARK_gtktypes_STEAL: {
+ GList * gtktypes = va_arg (__ap, GList *);
+ self->gtktypes = gtktypes;
+ break;
+ }
+ case QUARK_flags: {
+ GList * flags = va_arg (__ap, GList *);
+ GList * __old_value = self->flags;
+ self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
+ g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
+ break;
+ }
+ case QUARK_flags_STEAL: {
+ GList * flags = va_arg (__ap, GList *);
+ self->flags = flags;
+ break;
+ }
+ case QUARK_id: {
+ char * id = va_arg (__ap, char *);
+ char * __old_value = self->id;
+ self->id = g_strdup (id);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_id_STEAL: {
+ char * id = va_arg (__ap, char *);
+ self->id = id;
+ break;
+ }
+ case QUARK_args: {
+ GList * args = va_arg (__ap, GList *);
+ GList * __old_value = self->args;
+ self->args = node_list_copy (args);
+ node_list_free (__old_value);
+ break;
+ }
+ case QUARK_args_STEAL: {
+ GList * args = va_arg (__ap, GList *);
+ self->args = args;
+ break;
+ }
+ case QUARK_onerror: {
+ char * onerror = va_arg (__ap, char *);
+ char * __old_value = self->onerror;
+ self->onerror = g_strdup (onerror);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_onerror_STEAL: {
+ char * onerror = va_arg (__ap, char *);
+ self->onerror = onerror;
+ break;
+ }
+ case QUARK_defreturn: {
+ char * defreturn = va_arg (__ap, char *);
+ char * __old_value = self->defreturn;
+ self->defreturn = g_strdup (defreturn);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_defreturn_STEAL: {
+ char * defreturn = va_arg (__ap, char *);
+ self->defreturn = defreturn;
+ break;
+ }
+ case QUARK_cbuf: {
+ char * cbuf = va_arg (__ap, char *);
+ char * __old_value = self->cbuf;
+ self->cbuf = g_strdup (cbuf);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_cbuf_STEAL: {
+ char * cbuf = va_arg (__ap, char *);
+ self->cbuf = cbuf;
+ break;
+ }
+ case QUARK_line_no: {
+ int line_no = va_arg (__ap, int);
+ self->line_no = line_no;
+ break;
+ }
+ case QUARK_ccode_line: {
+ int ccode_line = va_arg (__ap, int);
+ self->ccode_line = ccode_line;
+ break;
+ }
+ case QUARK_vararg: {
+ gboolean vararg = va_arg (__ap, gboolean);
+ self->vararg = vararg;
+ break;
+ }
+ case QUARK_unique_id: {
+ int unique_id = va_arg (__ap, int);
+ self->unique_id = unique_id;
+ break;
+ }
+ case QUARK_bonobo_x_func: {
+ gboolean bonobo_x_func = va_arg (__ap, gboolean);
+ self->bonobo_x_func = bonobo_x_func;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Method::%s' does not exist", arg);
+ break;
+ }
+ }
}
-Node * copy_node(Node *node)
+static void
+setv_property (Property * self, va_list __ap)
{
- g_return_val_if_fail(node != NULL, NULL);
- g_return_val_if_fail(node->type >= 0 && node->type < LAST_NODE_TYPE, NULL);
- switch(node->type) {
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_gtktype: {
+ char * gtktype = va_arg (__ap, char *);
+ char * __old_value = self->gtktype;
+ self->gtktype = g_strdup (gtktype);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_gtktype_STEAL: {
+ char * gtktype = va_arg (__ap, char *);
+ self->gtktype = gtktype;
+ break;
+ }
+ case QUARK_ptype: {
+ Type * ptype = va_arg (__ap, Type *);
+ Type * __old_value = self->ptype;
+ self->ptype = copy_type (ptype);
+ free_type (__old_value);
+ break;
+ }
+ case QUARK_ptype_STEAL: {
+ Type * ptype = va_arg (__ap, Type *);
+ self->ptype = ptype;
+ break;
+ }
+ case QUARK_flags: {
+ GList * flags = va_arg (__ap, GList *);
+ GList * __old_value = self->flags;
+ self->flags = g_list_copy (flags); COPY_LIST_VALS(self->flags, g_strdup);
+ g_list_foreach (__old_value, (GFunc)g_free, NULL); g_list_free (__old_value);
+ break;
+ }
+ case QUARK_flags_STEAL: {
+ GList * flags = va_arg (__ap, GList *);
+ self->flags = flags;
+ break;
+ }
+ case QUARK_name: {
+ char * name = va_arg (__ap, char *);
+ char * __old_value = self->name;
+ self->name = g_strdup (name);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_name_STEAL: {
+ char * name = va_arg (__ap, char *);
+ self->name = name;
+ break;
+ }
+ case QUARK_nick: {
+ char * nick = va_arg (__ap, char *);
+ char * __old_value = self->nick;
+ self->nick = g_strdup (nick);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_nick_STEAL: {
+ char * nick = va_arg (__ap, char *);
+ self->nick = nick;
+ break;
+ }
+ case QUARK_blurb: {
+ char * blurb = va_arg (__ap, char *);
+ char * __old_value = self->blurb;
+ self->blurb = g_strdup (blurb);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_blurb_STEAL: {
+ char * blurb = va_arg (__ap, char *);
+ self->blurb = blurb;
+ break;
+ }
+ case QUARK_minimum: {
+ char * minimum = va_arg (__ap, char *);
+ char * __old_value = self->minimum;
+ self->minimum = g_strdup (minimum);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_minimum_STEAL: {
+ char * minimum = va_arg (__ap, char *);
+ self->minimum = minimum;
+ break;
+ }
+ case QUARK_maximum: {
+ char * maximum = va_arg (__ap, char *);
+ char * __old_value = self->maximum;
+ self->maximum = g_strdup (maximum);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_maximum_STEAL: {
+ char * maximum = va_arg (__ap, char *);
+ self->maximum = maximum;
+ break;
+ }
+ case QUARK_default_value: {
+ char * default_value = va_arg (__ap, char *);
+ char * __old_value = self->default_value;
+ self->default_value = g_strdup (default_value);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_default_value_STEAL: {
+ char * default_value = va_arg (__ap, char *);
+ self->default_value = default_value;
+ break;
+ }
+ case QUARK_extra_gtktype: {
+ char * extra_gtktype = va_arg (__ap, char *);
+ char * __old_value = self->extra_gtktype;
+ self->extra_gtktype = g_strdup (extra_gtktype);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_extra_gtktype_STEAL: {
+ char * extra_gtktype = va_arg (__ap, char *);
+ self->extra_gtktype = extra_gtktype;
+ break;
+ }
+ case QUARK_link: {
+ gboolean link = va_arg (__ap, gboolean);
+ self->link = link;
+ break;
+ }
+ case QUARK_export: {
+ gboolean export = va_arg (__ap, gboolean);
+ self->export = export;
+ break;
+ }
+ case QUARK_get: {
+ char * get = va_arg (__ap, char *);
+ char * __old_value = self->get;
+ self->get = g_strdup (get);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_get_STEAL: {
+ char * get = va_arg (__ap, char *);
+ self->get = get;
+ break;
+ }
+ case QUARK_get_line: {
+ int get_line = va_arg (__ap, int);
+ self->get_line = get_line;
+ break;
+ }
+ case QUARK_set: {
+ char * set = va_arg (__ap, char *);
+ char * __old_value = self->set;
+ self->set = g_strdup (set);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_set_STEAL: {
+ char * set = va_arg (__ap, char *);
+ self->set = set;
+ break;
+ }
+ case QUARK_set_line: {
+ int set_line = va_arg (__ap, int);
+ self->set_line = set_line;
+ break;
+ }
+ case QUARK_line_no: {
+ int line_no = va_arg (__ap, int);
+ self->line_no = line_no;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Property::%s' does not exist", arg);
+ break;
+ }
+ }
+}
+
+static void
+setv_type (Type * self, va_list __ap)
+{
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_name: {
+ char * name = va_arg (__ap, char *);
+ char * __old_value = self->name;
+ self->name = g_strdup (name);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_name_STEAL: {
+ char * name = va_arg (__ap, char *);
+ self->name = name;
+ break;
+ }
+ case QUARK_pointer: {
+ char * pointer = va_arg (__ap, char *);
+ char * __old_value = self->pointer;
+ self->pointer = g_strdup (pointer);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_pointer_STEAL: {
+ char * pointer = va_arg (__ap, char *);
+ self->pointer = pointer;
+ break;
+ }
+ case QUARK_postfix: {
+ char * postfix = va_arg (__ap, char *);
+ char * __old_value = self->postfix;
+ self->postfix = g_strdup (postfix);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_postfix_STEAL: {
+ char * postfix = va_arg (__ap, char *);
+ self->postfix = postfix;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Type::%s' does not exist", arg);
+ break;
+ }
+ }
+}
+
+static void
+setv_variable (Variable * self, va_list __ap)
+{
+ int quark;
+ const char *arg;
+ ensure_quarks ();
+ while ((arg = va_arg (__ap, char *)) != NULL) {
+ quark = GPOINTER_TO_INT (g_hash_table_lookup (quark_ht, arg));
+ switch (quark) {
+ case QUARK_scope: {
+ int scope = va_arg (__ap, int);
+ self->scope = scope;
+ break;
+ }
+ case QUARK_vtype: {
+ Type * vtype = va_arg (__ap, Type *);
+ Type * __old_value = self->vtype;
+ self->vtype = copy_type (vtype);
+ free_type (__old_value);
+ break;
+ }
+ case QUARK_vtype_STEAL: {
+ Type * vtype = va_arg (__ap, Type *);
+ self->vtype = vtype;
+ break;
+ }
+ case QUARK_id: {
+ char * id = va_arg (__ap, char *);
+ char * __old_value = self->id;
+ self->id = g_strdup (id);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_id_STEAL: {
+ char * id = va_arg (__ap, char *);
+ self->id = id;
+ break;
+ }
+ case QUARK_line_no: {
+ int line_no = va_arg (__ap, int);
+ self->line_no = line_no;
+ break;
+ }
+ case QUARK_destructor_unref: {
+ gboolean destructor_unref = va_arg (__ap, gboolean);
+ self->destructor_unref = destructor_unref;
+ break;
+ }
+ case QUARK_destructor: {
+ char * destructor = va_arg (__ap, char *);
+ char * __old_value = self->destructor;
+ self->destructor = g_strdup (destructor);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_destructor_STEAL: {
+ char * destructor = va_arg (__ap, char *);
+ self->destructor = destructor;
+ break;
+ }
+ case QUARK_destructor_line: {
+ int destructor_line = va_arg (__ap, int);
+ self->destructor_line = destructor_line;
+ break;
+ }
+ case QUARK_destructor_simple: {
+ gboolean destructor_simple = va_arg (__ap, gboolean);
+ self->destructor_simple = destructor_simple;
+ break;
+ }
+ case QUARK_initializer: {
+ char * initializer = va_arg (__ap, char *);
+ char * __old_value = self->initializer;
+ self->initializer = g_strdup (initializer);
+ g_free (__old_value);
+ break;
+ }
+ case QUARK_initializer_STEAL: {
+ char * initializer = va_arg (__ap, char *);
+ self->initializer = initializer;
+ break;
+ }
+ case QUARK_initializer_line: {
+ int initializer_line = va_arg (__ap, int);
+ self->initializer_line = initializer_line;
+ break;
+ }
+ default:
+ g_warning ("Argument named 'Variable::%s' does not exist", arg);
+ break;
+ }
+ }
+}
+
+Node *
+node_copy (Node *node)
+{
+ g_return_val_if_fail (node != NULL, NULL);
+ g_return_val_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE, NULL);
+ switch (node->type) {
case ARGUMENT_NODE: return (Node *)copy_argument ((Argument *)node);
case CCODE_NODE: return (Node *)copy_ccode ((CCode *)node);
case CHECK_NODE: return (Node *)copy_check ((Check *)node);
case CLASS_NODE: return (Node *)copy_class ((Class *)node);
case FUNCARG_NODE: return (Node *)copy_funcarg ((FuncArg *)node);
case METHOD_NODE: return (Node *)copy_method ((Method *)node);
+ case PROPERTY_NODE: return (Node *)copy_property ((Property *)node);
case TYPE_NODE: return (Node *)copy_type ((Type *)node);
case VARIABLE_NODE: return (Node *)copy_variable ((Variable *)node);
default: return NULL;
}
}
-void free_node(Node *node)
+static void
+node_setv (Node *node, va_list __ap)
+{
+ g_return_if_fail (node != NULL);
+ g_return_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE);
+ switch (node->type) {
+ case ARGUMENT_NODE: setv_argument ((Argument *)node, __ap); break;
+ case CCODE_NODE: setv_ccode ((CCode *)node, __ap); break;
+ case CHECK_NODE: setv_check ((Check *)node, __ap); break;
+ case CLASS_NODE: setv_class ((Class *)node, __ap); break;
+ case FUNCARG_NODE: setv_funcarg ((FuncArg *)node, __ap); break;
+ case METHOD_NODE: setv_method ((Method *)node, __ap); break;
+ case PROPERTY_NODE: setv_property ((Property *)node, __ap); break;
+ case TYPE_NODE: setv_type ((Type *)node, __ap); break;
+ case VARIABLE_NODE: setv_variable ((Variable *)node, __ap); break;
+ default: break;
+ }
+}
+
+void
+node_set (Node *node, ...)
+{
+ va_list __ap;
+ va_start (__ap, node);
+ node_setv (node, __ap);
+ va_end (__ap);
+}
+
+Node *
+node_new (NodeType type, ...)
+{
+ va_list __ap;
+ Node *node = NULL;
+ va_start (__ap, type);
+ g_return_val_if_fail (type >= 0 && type < LAST_NODE_TYPE, NULL);
+ switch (type) {
+ case ARGUMENT_NODE:
+ node = (Node *)g_new0 (Argument, 1);
+ node->type = type;
+ setv_argument ((Argument *)node, __ap);
+ break;
+ case CCODE_NODE:
+ node = (Node *)g_new0 (CCode, 1);
+ node->type = type;
+ setv_ccode ((CCode *)node, __ap);
+ break;
+ case CHECK_NODE:
+ node = (Node *)g_new0 (Check, 1);
+ node->type = type;
+ setv_check ((Check *)node, __ap);
+ break;
+ case CLASS_NODE:
+ node = (Node *)g_new0 (Class, 1);
+ node->type = type;
+ setv_class ((Class *)node, __ap);
+ break;
+ case FUNCARG_NODE:
+ node = (Node *)g_new0 (FuncArg, 1);
+ node->type = type;
+ setv_funcarg ((FuncArg *)node, __ap);
+ break;
+ case METHOD_NODE:
+ node = (Node *)g_new0 (Method, 1);
+ node->type = type;
+ setv_method ((Method *)node, __ap);
+ break;
+ case PROPERTY_NODE:
+ node = (Node *)g_new0 (Property, 1);
+ node->type = type;
+ setv_property ((Property *)node, __ap);
+ break;
+ case TYPE_NODE:
+ node = (Node *)g_new0 (Type, 1);
+ node->type = type;
+ setv_type ((Type *)node, __ap);
+ break;
+ case VARIABLE_NODE:
+ node = (Node *)g_new0 (Variable, 1);
+ node->type = type;
+ setv_variable ((Variable *)node, __ap);
+ break;
+ default: break;
+ }
+ va_end (__ap);
+ return node;
+}
+
+void
+node_free (Node *node)
{
- g_return_if_fail(node != NULL);
- g_return_if_fail(node->type >= 0 && node->type < LAST_NODE_TYPE);
- switch(node->type) {
+ g_return_if_fail (node != NULL);
+ g_return_if_fail (node->type >= 0 && node->type < LAST_NODE_TYPE);
+ switch (node->type) {
case ARGUMENT_NODE: free_argument ((Argument *)node); return;
case CCODE_NODE: free_ccode ((CCode *)node); return;
case CHECK_NODE: free_check ((Check *)node); return;
case CLASS_NODE: free_class ((Class *)node); return;
case FUNCARG_NODE: free_funcarg ((FuncArg *)node); return;
case METHOD_NODE: free_method ((Method *)node); return;
+ case PROPERTY_NODE: free_property ((Property *)node); return;
case TYPE_NODE: free_type ((Type *)node); return;
case VARIABLE_NODE: free_variable ((Variable *)node); return;
default: return;
}
}
-GList * copy_node_list(GList *nodes)
+GList *
+node_list_copy (GList *nodes)
{
GList *li;
- nodes = g_list_copy(nodes);
- for(li = nodes; li != NULL; li = li->next) {
- li->data = copy_node(li->data);
+ nodes = g_list_copy (nodes);
+ for (li = nodes; li != NULL; li = li->next) {
+ li->data = node_copy (li->data);
}
return nodes;
}
-void free_node_list(GList *nodes)
+void
+node_list_free (GList *nodes)
{
GList *li;
- for(li = nodes; li != NULL; li = li->next) {
- free_node(li->data);
+ for (li = nodes; li != NULL; li = li->next) {
+ node_free (li->data);
}
- g_list_free(nodes);
+ g_list_free (nodes);
}
projects / gob-dx.git / blobdiff