+ out_printf(out, "\t%s->%s = NULL;\n",
+ oname, m->id);
+ }
+ }
+ if(set_line)
+ out_addline_outfile(out);
+}
+
+static void
+make_argument (Argument *a)
+{
+ GString *flags;
+ GList *l;
+ char *s;
+ char *argflags[] = {
+ "CONSTRUCT",
+ "CONSTRUCT_ONLY",
+ "CHILD_ARG",
+ "MASK",
+ NULL
+ };
+
+ flags = g_string_new ("(GParamFlags)(");
+
+ if(a->get && a->set)
+ g_string_append (flags, "G_PARAM_READABLE | G_PARAM_WRITABLE");
+ else if(a->get)
+ g_string_append (flags, "G_PARAM_READABLE");
+ else
+ g_string_append (flags, "G_PARAM_WRITABLE");
+
+ g_assert(a->get || a->set);
+
+ for (l = a->flags; l != NULL; l = l->next) {
+ char *flag = l->data;
+ int i;
+ if(strcmp (flag, "READABLE") == 0 ||
+ strcmp (flag, "WRITABLE") == 0) {
+ error_print(GOB_WARN, a->line_no,
+ "READABLE and "
+ "WRITABLE argument flags are "
+ "set automatically");
+ continue;
+ }
+ for(i = 0; argflags[i]; i++) {
+ if(strcmp(argflags[i], flag)==0)
+ break;
+ }
+ /* if we haven't found it in our list */
+ if( ! argflags[i]) {
+ error_printf(GOB_WARN, a->line_no,
+ "Unknown flag '%s' used, "
+ "perhaps it was misspelled", flag);
+ }
+ g_string_sprintfa(flags, " | G_PARAM_%s", flag);
+ }
+
+ g_string_append (flags, ")");
+
+ s = g_strdup(a->name);
+ gob_strup (s);
+ if (!strcmp (a->gtktype, "ENUM"))
+ out_printf(out, "\tparam_spec = g_param_spec_enum (\"%s\", NULL, NULL,\n"
+ "\t\tG_TYPE_ENUM, 0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ if (!strcmp (a->gtktype, "FLAGS"))
+ out_printf(out, "\tparam_spec = g_param_spec_flags (\"%s\", NULL, NULL,\n"
+ "\t\tG_TYPE_FLAGS, 0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "OBJECT"))
+ out_printf(out, "\tparam_spec = g_param_spec_object (\"%s\", NULL, NULL,\n"
+ "\t\tG_TYPE_OBJECT,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "STRING"))
+ out_printf(out, "\tparam_spec = g_param_spec_string (\"%s\", NULL, NULL,\n"
+ "\t\tNULL,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "INT"))
+ out_printf(out, "\tparam_spec = g_param_spec_int (\"%s\", NULL, NULL,\n"
+ "\t\tG_MININT, G_MAXINT,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "UINT"))
+ out_printf(out, "\tparam_spec = g_param_spec_uint (\"%s\", NULL, NULL,\n"
+ "\t\t0, G_MAXUINT,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "INT"))
+ out_printf(out, "\tparam_spec = g_param_spec_int (\"%s\", NULL, NULL,\n"
+ "\t\tG_MININT, G_MAXINT,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "CHAR"))
+ out_printf(out, "\tparam_spec = g_param_spec_char (\"%s\", NULL, NULL,\n"
+ "\t\t-128, 127,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "UCHAR"))
+ out_printf(out, "\tparam_spec = g_param_spec_uchar (\"%s\", NULL, NULL,\n"
+ "\t\t0, 0xFF,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "BOOL") ||
+ !strcmp (a->gtktype, "BOOLEAN"))
+ out_printf(out, "\tparam_spec = g_param_spec_boolean (\"%s\", NULL, NULL,\n"
+ "\t\tFALSE,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "LONG"))
+ out_printf(out, "\tparam_spec = g_param_spec_long (\"%s\", NULL, NULL,\n"
+ "\t\tG_MINLONG, G_MAXLONG,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "ULONG"))
+ out_printf(out, "\tparam_spec = g_param_spec_ulong (\"%s\", NULL, NULL,\n"
+ "\t\t0, G_MAXULONG,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "INT64"))
+ out_printf(out, "\tparam_spec = g_param_spec_int64 (\"%s\", NULL, NULL,\n"
+ "\t\tG_MININT64, G_MAXINT64,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "UINT64"))
+ out_printf(out, "\tparam_spec = g_param_spec_uint64 (\"%s\", NULL, NULL,\n"
+ "\t\t0, G_MAXUINT64,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "FLOAT"))
+ out_printf(out, "\tparam_spec = g_param_spec_float (\"%s\", NULL, NULL,\n"
+ "\t\tG_MINFLOAT, G_MAXFLOAT,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "DOUBLE"))
+ out_printf(out, "\tparam_spec = g_param_spec_double (\"%s\", NULL, NULL,\n"
+ "\t\tG_MINDOUBLE, G_MAXDOUBLE,\n"
+ "\t\t0,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else if (!strcmp (a->gtktype, "POINTER"))
+ out_printf(out, "\tparam_spec = g_param_spec_pointer (\"%s\", NULL, NULL,\n"
+ "\t\t%s);\n",
+ a->name, flags->str);
+ else
+ error_printf (GOB_ERROR, a->line_no,
+ "%s type is not supported for arguments, try using properties",
+ a->gtktype);
+
+ out_printf(out, "\tg_object_class_install_property (g_object_class,\n"
+ "\t\tPROP_%s, param_spec);\n", s);
+
+
+ g_free(s);
+ g_string_free(flags, TRUE);
+}
+
+#define value_for_print(str, alt) (str != NULL ? str : alt)
+
+static void
+make_property (Property *p)
+{
+ GString *flags;
+ GList *l;
+ char *s;
+ char *argflags[] = {
+ "CONSTRUCT",
+ "CONSTRUCT_ONLY",
+ "CHILD_ARG",
+ "MASK",
+ NULL
+ };
+
+ flags = g_string_new ("(GParamFlags)(");
+
+ if (p->get != NULL && p->set != NULL)
+ g_string_append (flags, "G_PARAM_READABLE | G_PARAM_WRITABLE");
+ else if (p->get != NULL)
+ g_string_append (flags, "G_PARAM_READABLE");
+ else
+ g_string_append (flags, "G_PARAM_WRITABLE");
+
+ if (p->get == NULL && p->set == NULL) {
+ error_print (GOB_ERROR, p->line_no,
+ "Property has no getter nor setter");
+ }
+
+ for (l = p->flags; l != NULL; l = l->next) {
+ char *flag = l->data;
+ int i;
+ if(strcmp (flag, "READABLE") == 0 ||
+ strcmp (flag, "WRITABLE") == 0) {
+ error_print(GOB_WARN, p->line_no,
+ "READABLE and "
+ "WRITABLE argument flags are "
+ "set automatically");
+ continue;
+ }
+ for(i = 0; argflags[i]; i++) {
+ if(strcmp(argflags[i], flag)==0)
+ break;
+ }
+ /* if we haven't found it in our list */
+ if( ! argflags[i]) {
+ error_printf(GOB_WARN, p->line_no,
+ "Unknown flag '%s' used, "
+ "perhaps it was misspelled", flag);
+ }
+ g_string_sprintfa(flags, " | G_PARAM_%s", flag);
+ }
+
+ g_string_append (flags, ")");
+
+ if (strcmp (p->gtktype, "CHAR") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_char\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "-128"),
+ value_for_print (p->maximum, "127"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "UCHAR") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_uchar\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "0"),
+ value_for_print (p->maximum, "0xFF"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "BOOLEAN") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_boolean\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->default_value, "FALSE"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "INT") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_int\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "G_MININT"),
+ value_for_print (p->maximum, "G_MAXINT"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "UINT") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_uint\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "0"),
+ value_for_print (p->maximum, "G_MAXUINT"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "LONG") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_long\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "G_MINLONG"),
+ value_for_print (p->maximum, "G_MAXLONG"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "ULONG") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_ulong\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "0"),
+ value_for_print (p->maximum, "G_MAXULONG"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "INT64") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_int64\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "G_MININT64"),
+ value_for_print (p->maximum, "G_MAXINT64"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "UINT64") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_uint64\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "0"),
+ value_for_print (p->maximum, "G_MAXUINT64"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "UNICHAR") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_unichar\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "ENUM") == 0) {
+ char *type = make_me_type (p->extra_gtktype,
+ "G_TYPE_ENUM");
+ out_printf (out, "\tparam_spec = g_param_spec_enum\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* enum_type */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ type,
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ g_free (type);
+ } else if (strcmp (p->gtktype, "FLAGS") == 0) {
+ char *type = make_me_type (p->extra_gtktype,
+ "G_TYPE_FLAGS");
+ out_printf (out, "\tparam_spec = g_param_spec_flags\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* flags_type */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ type,
+ value_for_print (p->default_value, "0"),
+ flags->str);
+ g_free (type);
+ } else if (strcmp (p->gtktype, "FLOAT") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_float\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "G_MINFLOAT"),
+ value_for_print (p->maximum, "G_MAXFLOAT"),
+ value_for_print (p->default_value, "0.0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "DOUBLE") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_double\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* minimum */,\n"
+ "\t\t %s /* maximum */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->minimum, "G_MINDOUBLE"),
+ value_for_print (p->maximum, "G_MAXDOUBLE"),
+ value_for_print (p->default_value, "0.0"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "STRING") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_string\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* default_value */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ value_for_print (p->default_value, "NULL"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "PARAM") == 0) {
+ char *type = make_me_type (p->extra_gtktype,
+ "G_TYPE_PARAM");
+ out_printf (out, "\tparam_spec = g_param_spec_param\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* param_type */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ type,
+ flags->str);
+ g_free (type);
+ } else if (strcmp (p->gtktype, "BOXED") == 0) {
+ char *type = make_me_type (p->extra_gtktype,
+ "G_TYPE_BOXED");
+ out_printf (out, "\tparam_spec = g_param_spec_boxed\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* boxed_type */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ type,
+ flags->str);
+ g_free (type);
+ } else if (strcmp (p->gtktype, "POINTER") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_pointer\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ flags->str);
+ /* FIXME: VALUE_ARRAY */
+ } else if (strcmp (p->gtktype, "CLOSURE") == 0) {
+ out_printf (out, "\tparam_spec = g_param_spec_pointer\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ flags->str);
+ } else if (strcmp (p->gtktype, "OBJECT") == 0) {
+ char *type = make_me_type (p->extra_gtktype,
+ "G_TYPE_BOXED");
+ out_printf (out, "\tparam_spec = g_param_spec_object\n"
+ "\t\t(\"%s\" /* name */,\n"
+ "\t\t %s /* nick */,\n"
+ "\t\t %s /* blurb */,\n"
+ "\t\t %s /* object_type */,\n"
+ "\t\t %s);\n",
+ p->name,
+ value_for_print (p->nick, "NULL"),
+ value_for_print (p->blurb, "NULL"),
+ type,
+ flags->str);
+ g_free (type);
+ } else {
+ error_printf (GOB_ERROR, p->line_no,
+ "%s type is not supported by properties",
+ p->gtktype);
+ }
+
+ s = g_strdup (p->name);
+ gob_strup (s);
+ out_printf (out, "\tg_object_class_install_property (g_object_class,\n"
+ "\t\tPROP_%s,\n"
+ "\t\tparam_spec);\n", s);
+ g_free (s);
+
+ g_string_free (flags, TRUE);
+}
+
+static void
+make_arguments(Class *c)
+{
+ GList *li;
+ if (get_properties > 0)
+ out_printf(out, "\tg_object_class->get_property = ___object_get_property;\n");
+ if (set_properties > 0)
+ out_printf(out, "\tg_object_class->set_property = ___object_set_property;\n");
+ out_printf (out, " {\n"
+ "\tGParamSpec *param_spec;\n\n");
+
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ if (n->type == PROPERTY_NODE)
+ make_property ((Property *)n);
+ else if (n->type == ARGUMENT_NODE)
+ make_argument ((Argument *)n);
+ }
+ out_printf(out, " }\n");
+}
+
+static void
+print_initializer(Method *m, Variable *v)
+{
+ char *root;
+
+ if(v->initializer == NULL)
+ return;
+
+ if(v->scope == PRIVATE_SCOPE)
+ root = g_strconcat(((FuncArg *)m->args->data)->name,
+ "->_priv", NULL);
+ else
+ root = g_strdup(((FuncArg *)m->args->data)->name);
+
+ if(v->initializer_line > 0)
+ out_addline_infile(out, v->initializer_line);
+
+ out_printf(out, "\t%s->%s = %s;\n",
+ root, v->id, v->initializer);
+
+ if(v->initializer_line > 0)
+ out_addline_outfile(out);
+
+ g_free(root);
+}
+
+static void
+print_destructor (Variable *v)
+{
+ const char *root;
+
+ if(v->destructor == NULL)
+ return;
+
+ if(v->scope == PRIVATE_SCOPE)
+ root = "self->_priv";
+ else
+ root = "self";
+
+ if(v->destructor_simple) {
+ if(v->destructor_line > 0)
+ out_addline_infile(out, v->destructor_line);
+
+ out_printf(out, "\tif(%s->%s) { "
+ "((*(void (*)(void *))%s)) (%s->%s); "
+ "%s->%s = NULL; }\n",
+ root, v->id, v->destructor, root, v->id,
+ root, v->id);
+
+ if(v->destructor_line > 0)
+ out_addline_outfile(out);
+ } else {
+ out_printf(out, "#define %s (%s->%s)\n", v->id, root, v->id);
+ out_printf(out, "#define VAR %s\n", v->id);
+ out_printf(out, "\t{\n");
+ if(v->destructor_line > 0)
+ out_addline_infile(out, v->destructor_line);
+
+ out_printf(out, "\t%s}\n", v->destructor);
+
+ if(v->destructor_line > 0)
+ out_addline_outfile(out);
+ out_printf(out, "\tmemset(&%s, 0, sizeof(%s));\n",
+ v->id, v->id);
+ out_printf(out, "#undef VAR\n");
+ out_printf(out, "#undef %s\n", v->id);
+ }
+}
+
+static void
+add_dispose (Class *c)
+{
+ out_printf(out, "\nstatic void\n"
+ "___dispose (GObject *obj_self)\n"
+ "{\n");
+ out_printf(out,
+ "#define __GOB_FUNCTION__ \"%s::dispose\"\n",
+ c->otype);
+
+ if (unreftors > 0) {
+ out_printf (out, "\t%s *self%s = %s (obj_self);\n",
+ typebase,
+ ! no_gnu ? " G_GNUC_UNUSED" : "",
+ macrobase);
+ }
+
+ if (dispose_handler != NULL) {
+ /* so we get possible bad argument warning */
+ if (dispose_handler->line_no > 0)
+ out_addline_infile (out, dispose_handler->line_no);
+ out_printf (out, "\t___%x_%s_dispose(obj_self);\n",
+ (guint)dispose_handler->unique_id, funcbase);
+ if (dispose_handler->line_no > 0)
+ out_addline_outfile (out);
+ } else {
+ out_printf (out,
+ "\tif (G_OBJECT_CLASS (parent_class)->dispose) \\\n"
+ "\t\t(* G_OBJECT_CLASS (parent_class)->dispose) (obj_self);\n");
+ }
+
+ if (unreftors > 0) {
+ GList *li;
+ for(li = ((Class *)class)->nodes;
+ li != NULL;
+ li = li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if (n->type == VARIABLE_NODE &&
+ v->scope != CLASS_SCOPE &&
+ v->destructor_unref)
+ print_destructor (v);
+ }
+ }
+
+ out_printf(out, "}\n"
+ "#undef __GOB_FUNCTION__\n\n");
+}
+
+static void
+add_finalize (Class *c)
+{
+ out_printf(out,
+ "\nstatic void\n"
+ "___finalize(GObject *obj_self)\n"
+ "{\n");
+ out_printf(out,
+ "#define __GOB_FUNCTION__ \"%s::finalize\"\n",
+ c->otype);
+
+ if (privates > 0 ||
+ destructors > 0) {
+ const char *unused = "";
+ if ( ! no_gnu)
+ unused = " G_GNUC_UNUSED";
+ out_printf(out, "\t%s *self %s = %s (obj_self);\n",
+ typebase, unused, macrobase);
+ }
+ if (privates > 0) {
+ out_printf(out, "\tgpointer priv = self->_priv;\n");
+ }
+
+ if(finalize_handler) {
+ /* so we get possible bad argument warning */
+ if(finalize_handler->line_no > 0)
+ out_addline_infile(out, finalize_handler->line_no);
+ out_printf(out, "\t___%x_%s_finalize(obj_self);\n",
+ (guint)finalize_handler->unique_id, funcbase);
+ if(finalize_handler->line_no > 0)
+ out_addline_outfile(out);
+ } else {
+ out_printf(out,
+ "\tif(G_OBJECT_CLASS(parent_class)->finalize) \\\n"
+ "\t\t(* G_OBJECT_CLASS(parent_class)->finalize)(obj_self);\n");
+ }
+
+ if (destructors > 0) {
+ GList *li;
+ for (li = ((Class *)class)->nodes;
+ li != NULL;
+ li = li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if (n->type == VARIABLE_NODE &&
+ v->scope != CLASS_SCOPE &&
+ ! v->destructor_unref)
+ print_destructor (v);
+ }
+ }
+
+ if (privates > 0) {
+ out_printf(out, "\tg_free (priv);\n");
+ }
+
+ out_printf(out, "}\n"
+ "#undef __GOB_FUNCTION__\n\n");
+}
+
+static void
+make_bonobo_object_epv (Class *c, const char *classname)
+{
+ GList *li;
+ gboolean added_line = FALSE;
+
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ Method *m = (Method *)n;
+ if(n->type != METHOD_NODE ||
+ m->method == OVERRIDE_METHOD)
+ continue;
+
+ if (m->bonobo_object_func) {
+ if(m->line_no > 0) {
+ out_addline_infile(out, m->line_no);
+ added_line = TRUE;
+ } else if (m->line_no == 0 &&
+ added_line) {
+ out_addline_outfile(out);
+ added_line = FALSE;
+ }
+ out_printf (out, "\t%s->_epv.%s = self_%s;\n",
+ classname, m->id, m->id);
+ }
+ }
+ if (added_line)
+ out_addline_outfile(out);
+}
+
+static void
+add_inits(Class *c)
+{
+ const char *unused = "";
+ GList *li;
+
+ if ( ! no_gnu)
+ unused = " G_GNUC_UNUSED";
+
+ for(li=c->nodes;li;li=g_list_next(li)) {
+ Node *n = li->data;
+ Method *m;
+
+ if(n->type != METHOD_NODE)
+ continue;
+ m = (Method *)n;
+ if(m->method == INIT_METHOD) {
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ print_method(out, "static ", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, TRUE, FALSE);
+ if(m->line_no > 0)
+ out_addline_outfile(out);
+ out_printf(out, "{\n"
+ "#define __GOB_FUNCTION__ \"%s::init\"\n",
+ c->otype);
+ if(privates > 0) {
+ out_printf(out, "\t%s->_priv = "
+ "g_new0 (%sPrivate, 1);\n",
+ ((FuncArg *)m->args->data)->name,
+ typebase);
+ } else if(always_private_struct) {
+ out_printf(out, "\t%s->_priv = NULL;\n",
+ ((FuncArg *)m->args->data)->name);
+ }
+ if(initializers > 0) {
+ GList *li;
+ for(li = ((Class *)class)->nodes;
+ li != NULL;
+ li = li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if(n->type != VARIABLE_NODE ||
+ v->scope == CLASS_SCOPE)
+ continue;
+ print_initializer(m, v);
+ }
+ }
+ } else if(m->method == CLASS_INIT_METHOD) {
+ gboolean did_base_obj = FALSE;
+
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ print_method(out, "static ", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, TRUE, FALSE);
+ if(m->line_no > 0)
+ out_addline_outfile(out);
+ out_printf(out, "{\n"
+ "#define __GOB_FUNCTION__ \"%s::class_init\"\n",
+ c->otype);
+ if (set_properties > 0 ||
+ get_properties > 0 ||
+ signals > 0 ||
+ need_dispose ||
+ need_finalize) {
+ out_printf(out,
+ "\tGObjectClass *"
+ "g_object_class%s = "
+ "(GObjectClass*) %s;\n",
+ unused,
+ ((FuncArg *)m->args->data)->name);
+ did_base_obj = TRUE;
+ }
+
+ if (overrides > 0)
+ add_overrides (c,
+ ((FuncArg *)m->args->data)->name,
+ did_base_obj);
+
+ if (initializers > 0) {
+ GList *li;
+ for(li = ((Class *)class)->nodes;
+ li != NULL;
+ li = li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if(n->type == VARIABLE_NODE &&
+ v->scope == CLASS_SCOPE)
+ print_initializer(m, v);
+ }
+ }
+
+ out_printf(out, "\n\tparent_class = ");
+ if(for_cpp)
+ out_printf(out, "(%sClass *)", ptypebase);
+ out_printf(out, "g_type_class_ref (%s);\n",
+ pmacrotype);
+
+ if(signals > 0)
+ add_signals(c);
+
+ set_def_handlers(c, ((FuncArg *)m->args->data)->name);
+
+ /* if there are no handlers for these things, we
+ * need to set them up here */
+ if(need_dispose && !dispose_handler)
+ out_printf(out, "\tg_object_class->dispose "
+ "= ___dispose;\n");
+ if(need_finalize && !finalize_handler)
+ out_printf(out, "\tg_object_class->finalize = "
+ "___finalize;\n");
+
+ if(get_properties > 0 || set_properties > 0)
+ make_arguments(c);
+
+ if (c->bonobo_object_class != NULL) {
+ make_bonobo_object_epv (c, ((FuncArg *)m->args->data)->name);
+ }
+ } else
+ continue;
+
+ if(m->cbuf) {
+ out_printf(out, " {\n");
+ out_addline_infile(out, m->ccode_line);
+ out_printf(out, "%s\n", m->cbuf);
+ out_addline_outfile(out);
+ out_printf(out, " }\n");
+ }
+ out_printf(out, "}\n"
+ "#undef __GOB_FUNCTION__\n");
+ }
+}
+
+static void
+add_argument (Argument *a, gboolean is_set)
+{
+ char *s;
+ char *cbuf;
+ char *the_type_lower;
+ int line_no;
+
+ if(is_set) {
+ cbuf = a->set;
+ line_no = a->set_line;
+ } else {
+ cbuf = a->get;
+ line_no = a->get_line;
+ }
+ if (cbuf == NULL)
+ return;
+ s = g_strdup(a->name);
+ gob_strup (s);
+ out_printf(out, "\tcase PROP_%s:\n\t{", s);
+
+ the_type_lower = g_strdup (a->gtktype);
+ gob_strdown (the_type_lower);
+
+ /* HACK because there is no g_value_set/get for unichar */
+ if (strcmp (the_type_lower, "unichar") == 0) {
+ g_free (the_type_lower);
+ the_type_lower = g_strdup ("uint");
+ }
+
+ if (is_set) {
+ char *cast;
+ const char *unused = "";
+
+ if ( ! no_gnu && ! for_cpp /* g++ has a cow with this */) {
+ unused = " G_GNUC_UNUSED";
+ }
+
+ if (a->atype != NULL &&
+ /* gcc -Wbad-function-cast is wanking stupid, moronic
+ and otherwise evil so we should just use a (gint)
+ or (guint) cast, not the specific type cast */
+ (for_cpp ||
+ (strcmp (a->gtktype, "ENUM") != 0 &&
+ strcmp (a->gtktype, "FLAGS") != 0)))
+ cast = get_type (a->atype, TRUE);
+ else
+ cast = g_strdup (get_cast (a->gtktype, FALSE));
+
+ out_printf (out, "\t%s ARG%s = (%s) g_value_get_%s (VAL);\n",
+ cast, unused, cast, the_type_lower);
+
+ g_free (cast);
+ } else if ( ! is_set) {
+ char *cast;
+
+ if (a->atype != NULL)
+ cast = get_type (a->atype, TRUE);
+ else
+ cast = g_strdup (get_cast (a->gtktype, FALSE));
+ out_printf (out, "\t%s ARG;\n"
+ "\tmemset (&ARG, 0, sizeof (%s));\n",
+ cast, cast);
+
+ g_free(cast);
+ }
+ g_free (s);
+ out_printf(out, "\t\t{\n");
+ if (line_no > 0)
+ out_addline_infile (out, line_no);
+ out_printf (out, "%s\n", cbuf);
+ if (line_no > 0)
+ out_addline_outfile (out);
+ out_printf (out, "\t\t}\n");
+ if ( ! is_set) {
+ if (strcmp (a->gtktype, "OBJECT") == 0)
+ out_printf (out, "\t\tg_value_set_%s (VAL, G_OBJECT (ARG));\n",
+ the_type_lower);
+ else
+ out_printf (out, "\t\t"
+ "g_value_set_%s (VAL, ARG);\n",
+ the_type_lower);
+ }
+ g_free (the_type_lower);
+
+ if (is_set &&
+ (no_gnu || for_cpp /* g++ has a cow with G_GNUC_UNUSED */)) {
+ out_printf (out, "\t\tif (&ARG) break;\n");
+ }
+
+ out_printf (out, "\t\tbreak;\n");
+
+ out_printf (out, "\t}\n");
+}
+
+static void
+add_property (Property *p, gboolean is_set)
+{
+ const char *cbuf;
+ char *the_type_lower;
+ char *name_upper;
+ int line_no;
+
+ if (is_set) {
+ cbuf = p->set;
+ line_no = p->set_line;
+ } else {
+ cbuf = p->get;
+ line_no = p->get_line;
+ }
+ if (cbuf == NULL)
+ return;
+
+ name_upper = g_strdup (p->name);
+ gob_strup (name_upper);
+ the_type_lower = g_strdup (p->gtktype);
+ gob_strdown (the_type_lower);
+
+ out_printf (out, "\tcase PROP_%s:\n", name_upper);
+
+ out_printf(out, "\t\t{\n");
+ if (line_no > 0)
+ out_addline_infile (out, line_no);
+ out_printf (out, "%s\n", cbuf);
+ if (line_no > 0)
+ out_addline_outfile (out);
+ out_printf (out, "\t\t}\n");
+
+ g_free (name_upper);
+ g_free (the_type_lower);
+
+ out_printf (out, "\t\tbreak;\n");
+}
+
+static void
+add_getset_arg(Class *c, gboolean is_set)
+{
+ GList *li;
+ const char *unused = "";
+ const char *hack_unused = "";
+
+ if ( ! no_gnu && ! for_cpp /* g++ has a cow with this */) {
+ unused = " G_GNUC_UNUSED";
+ } else {
+ hack_unused = "if (&VAL || &pspec) break;\n\t\t";
+ }
+
+ out_printf(out, "\nstatic void\n"
+ "___object_%s_property (GObject *object,\n"
+ "\tguint property_id,\n"
+ "\t%sGValue *VAL%s,\n"
+ "\tGParamSpec *pspec%s)\n"
+ "#define __GOB_FUNCTION__ \"%s::%s_property\"\n"
+ "{\n"
+ "\t%s *self%s;\n\n"
+ "\tself = %s (object);\n\n"
+ "\tswitch (property_id) {\n",
+ is_set ? "set" : "get",
+ is_set ? "const " : "",
+ unused,
+ unused,
+ c->otype,
+ is_set ? "set" : "get",
+ typebase,
+ unused,
+ macrobase);
+
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ if (n->type == PROPERTY_NODE)
+ add_property ((Property *)n, is_set);
+ else if (n->type == ARGUMENT_NODE)
+ add_argument ((Argument *)n, is_set);
+ }
+ out_printf (out, "\tdefault:\n"
+ "/* Apparently in g++ this is needed, glib is b0rk */\n"
+ "#ifndef __PRETTY_FUNCTION__\n"
+ "# undef G_STRLOC\n"
+ "# define G_STRLOC __FILE__ \":\" G_STRINGIFY (__LINE__)\n"
+ "#endif\n"
+ "\t\tG_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);\n"
+ "\t\t%sbreak;\n\t}\n"
+ "}\n"
+ "#undef __GOB_FUNCTION__\n", hack_unused);
+}
+
+static void
+print_checks (Method *m, FuncArg *fa)
+{
+ GList *li;
+ gboolean is_void;
+ gboolean checked_null = FALSE;
+ is_void = (strcmp(m->mtype->name, "void")==0 &&
+ m->mtype->pointer == NULL);
+
+ for(li = fa->checks; li != NULL; li = li->next) {
+ Check *ch = li->data;
+ char *s;
+ /* point to the method prot in .gob for failed checks */
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ if(is_void)
+ out_printf(out, "\tg_return_if_fail (");
+ else
+ out_printf(out, "\tg_return_val_if_fail (");
+ switch(ch->chtype) {
+ case NULL_CHECK:
+ out_printf(out, "%s != NULL", fa->name);
+ checked_null = TRUE;
+ break;
+ case TYPE_CHECK:
+ s = make_pre_macro(fa->atype->name, "IS");
+ if(checked_null)
+ out_printf(out, "%s (%s)", s, fa->name);
+ else
+ /* if not check null, null may be valid */
+ out_printf(out, "!(%s) || %s (%s)", fa->name,
+ s, fa->name);
+ g_free(s);
+ break;
+ case LT_CHECK:
+ out_printf(out, "%s < %s", fa->name, ch->number);
+ break;
+ case GT_CHECK:
+ out_printf(out, "%s > %s", fa->name, ch->number);
+ break;
+ case LE_CHECK:
+ out_printf(out, "%s <= %s", fa->name, ch->number);
+ break;
+ case GE_CHECK:
+ out_printf(out, "%s >= %s", fa->name, ch->number);
+ break;
+ case EQ_CHECK:
+ out_printf(out, "%s == %s", fa->name, ch->number);
+ break;
+ case NE_CHECK:
+ out_printf(out, "%s != %s", fa->name, ch->number);
+ break;
+ }
+ if(is_void)
+ out_printf(out, ");\n");
+ else {
+ out_printf(out, ", (");
+ print_type(out, m->mtype, TRUE);
+ out_printf(out, ")%s);\n",
+ m->onerror?m->onerror:"0");
+ }
+ }
+}
+
+static void
+print_preconditions(Method *m)
+{
+ GList *li;
+
+ for(li=m->args;li;li=g_list_next(li)) {
+ FuncArg *fa = li->data;
+ if(fa->checks)
+ print_checks(m, fa);
+ }
+ if(m->line_no>0)
+ out_addline_outfile(out);
+}
+
+static void
+print_method_body (Method *m, gboolean pre, gboolean unused_self)
+{
+ if (m->line_no > 0)
+ out_addline_outfile(out);
+ out_printf(out, "{\n"
+ "#define __GOB_FUNCTION__ \"%s::%s\"\n",
+ ((Class *)class)->otype,
+ m->id);
+ if (pre)
+ print_preconditions(m);
+
+ if ( ! pre &&
+ unused_self &&
+ (no_gnu || for_cpp) &&
+ m->args != NULL &&
+ ((FuncArg *)(m->args->data))->name != NULL &&
+ strcmp (((FuncArg *)(m->args->data))->name, "self") == 0) {
+ out_printf (out, "\tif (&self) { ; }\n");
+ }
+
+ /* Note: the trailing }'s are on one line, this is so
+ that we get the no return warning correctly and point to
+ the correct line in the .gob file, yes this is slightly
+ ugly in the .c file, but that is not supposed to be
+ human readable anyway. */
+ if(m->cbuf) {
+ out_printf(out, "{\n");
+ if(m->ccode_line>0)
+ out_addline_infile(out, m->ccode_line);
+ out_printf(out, "\t%s}", m->cbuf);
+ }
+
+ /* Note, there is no \n between the last } and this } so that
+ * errors/warnings reported on the end of the body get pointed to the
+ * right line in the .gob source */
+ out_printf(out, "}\n");
+
+ if(m->cbuf)
+ out_addline_outfile(out);
+ out_printf(out, "#undef __GOB_FUNCTION__\n");
+}
+
+static void
+put_signal_args (Method *m)
+{
+ GList *li;
+ GList *ali;
+ int i;
+
+ if (m->args->next == NULL)
+ return;
+
+ for (ali = m->gtktypes->next, li = m->args->next, i = 1;
+ li != NULL && ali != NULL;
+ li = li->next, ali = ali->next, i++) {
+ FuncArg *fa = li->data;
+ char *cast = g_strdup (get_cast (ali->data, FALSE));
+ /* FIXME: This code is so fucking ugly it hurts */
+ gboolean do_static =
+ (strcmp ((char *)ali->data, "STRING") == 0 ||
+ strcmp ((char *)ali->data, "BOXED") == 0);
+ char *set_func;
+
+ if (cast == NULL) {
+ cast = get_type (fa->atype, TRUE);
+ }
+ /* we should have already proved before that
+ the we know all the types */
+ g_assert (cast != NULL);
+
+ out_printf (out,
+ "\t___param_values[%d].g_type = 0;\n"
+ "\tg_value_init (&___param_values[%d], G_TYPE_%s);\n",
+ i, i, (char *)ali->data);
+
+ if (strcmp (ali->data, "UNICHAR") == 0)
+ /* hack because glib is braindamaged */
+ set_func = g_strdup ("g_value_set_uint");
+ else
+ set_func = g_strdup_printf ("g_value_set%s_%s",
+ do_static ? "_static" : "",
+ (char *)ali->data);
+ gob_strdown (set_func);
+
+ out_printf (out, "\t%s (&___param_values[%d], (%s) %s);\n\n",
+ set_func, i, cast, fa->name);
+
+ g_free (set_func);
+ g_free (cast);
+ }
+}
+
+static void
+clear_signal_args (Method *m)
+{
+ GList *li;
+ int i;
+
+ out_printf (out, "\n\tg_value_unset (&___param_values[0]);\n");
+
+ if (m->args->next == NULL)
+ return;
+
+ for (li = m->args->next, i = 1;
+ li != NULL;
+ li = li->next, i++) {
+ out_printf (out,
+ "\tg_value_unset (&___param_values[%d]);\n", i);
+ }
+}
+
+static char *
+get_arg_names_for_macro (Method *m)
+{
+ const char *sep;
+ GList *li;
+ GString *gs = g_string_new(NULL);
+ sep = "";
+ for(li=m->args;li;li=g_list_next(li)) {
+ FuncArg *arg = li->data;
+ g_string_sprintfa (gs, "%s___%s", sep, arg->name);
+ sep = ",";
+ }
+ return g_string_free (gs, FALSE);
+}
+
+static void
+put_method(Method *m)
+{
+ char *s, *args, *doc;
+ gboolean is_void;
+ is_void = (strcmp(m->mtype->name, "void")==0 &&
+ m->mtype->pointer == NULL);
+ out_printf(out, "\n");
+ if(m->method != OVERRIDE_METHOD) {
+ doc = get_gtk_doc(m->id);
+ if(doc) {
+ out_printf(out, "%s", doc);
+ g_free(doc);
+ }
+ }
+ switch(m->method) {
+ case REGULAR_METHOD:
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ if(m->scope == PRIVATE_SCOPE)
+ print_method(out, "static ", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, FALSE, FALSE);
+ else /* PUBLIC, PROTECTED */
+ print_method(out, "", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, FALSE, FALSE);
+ print_method_body(m, TRUE, TRUE);
+ /* the outfile line was added above */
+ break;
+ case SIGNAL_FIRST_METHOD:
+ case SIGNAL_LAST_METHOD:
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ if(m->scope == PRIVATE_SCOPE)
+ print_method(out, "static ", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, FALSE, FALSE);
+ else /* PUBLIC, PROTECTED */
+ print_method(out, "", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, FALSE, FALSE);
+ out_addline_outfile (out);
+
+ out_printf (out, "{\n");
+
+ out_printf (out,
+ "\tGValue ___param_values[%d];\n"
+ "\tGValue ___return_val;\n\n"
+ "memset (&___return_val, 0, "
+ "sizeof (___return_val));\n"
+ "memset (&___param_values, 0, "
+ "sizeof (___param_values));\n\n",
+ g_list_length (m->args));
+
+ print_preconditions (m);
+
+ out_printf (out,
+ "\n\t___param_values[0].g_type = 0;\n"
+ "\tg_value_init (&___param_values[0], G_TYPE_FROM_INSTANCE (%s));\n"
+ "\tg_value_set_instance (&___param_values[0], (gpointer) %s);\n\n",
+ ((FuncArg *)m->args->data)->name,
+ ((FuncArg *)m->args->data)->name);
+
+ put_signal_args (m);
+
+ if (strcmp (m->gtktypes->data, "NONE") != 0) {
+ const char *defret = NULL;
+
+ out_printf (out, "\tg_value_init (&___return_val, G_TYPE_%s);\n",
+ (char *)m->gtktypes->data);
+
+ if (m->defreturn != NULL)
+ defret = m->defreturn;
+ else if (m->onerror != NULL)
+ defret = m->onerror;
+
+ if (defret != NULL) {
+ char *set_func;
+ /* FIXME: This code is so fucking ugly it hurts */
+ gboolean do_static =
+ (strcmp ((char *)m->gtktypes->data, "STRING") == 0 ||
+ strcmp ((char *)m->gtktypes->data, "BOXED") == 0);
+ char *cast = g_strdup (get_cast (m->gtktypes->data, FALSE));
+ if (cast == NULL)
+ cast = get_type (m->mtype, TRUE);
+
+ if (strcmp (m->gtktypes->data, "UNICHAR") == 0)
+ /* hack because glib is braindamaged */
+ set_func = g_strdup ("g_value_set_uint");
+ else
+ set_func = g_strdup_printf ("g_value_set%s_%s",
+ do_static ? "_static" : "",
+ (char *)m->gtktypes->data);
+ gob_strdown (set_func);
+
+ out_printf (out, "\t%s (&___return_val, (%s) (%s));\n",
+ set_func, cast, defret);
+
+ g_free (set_func);
+ g_free (cast);
+ }
+ out_printf (out, "\n");
+ }
+
+ s = g_strdup (m->id);
+ gob_strup (s);
+
+ out_printf(out, "\tg_signal_emitv (___param_values,\n"
+ "\t\tobject_signals[%s_SIGNAL],\n"
+ "\t\t0 /* detail */,\n"
+ "\t\t&___return_val);\n", s);
+
+ g_free (s);
+
+ clear_signal_args (m);
+
+ if (strcmp (m->gtktypes->data, "NONE") != 0) {
+ char *cast = g_strdup (get_cast (m->gtktypes->data, FALSE));
+ char *getfunc;
+ /* Hack because glib is very very braindead */
+ gboolean do_dup =
+ (strcmp ((char *)m->gtktypes->data, "STRING") == 0 ||
+ strcmp ((char *)m->gtktypes->data, "BOXED") == 0 ||
+ strcmp ((char *)m->gtktypes->data, "OBJECT") == 0 ||
+ strcmp ((char *)m->gtktypes->data, "PARAM") == 0);
+
+ if (strcmp (m->gtktypes->data, "UNICHAR") == 0)
+ /* hack because glib is braindamaged */
+ getfunc = g_strdup ("g_value_get_uint");
+ else
+ getfunc = g_strdup_printf ("g_value_%s_%s",
+ do_dup ? "dup" : "get",
+ (char *)m->gtktypes->data);
+ gob_strdown (getfunc);
+
+ if (cast == NULL)
+ cast = get_type (m->mtype, TRUE);
+
+ out_printf (out,
+ "\n\t{\n"
+ "\t\t");
+ print_type (out, m->mtype, TRUE);
+ out_printf (out,
+ " ___ret = (%s) %s (&___return_val);\n"
+ "\t\tg_value_unset (&___return_val);\n"
+ "\t\treturn ___ret;\n"
+ "\t}\n",
+ cast, getfunc);
+
+ g_free (cast);
+ g_free (getfunc);
+ }
+ out_printf(out, "}\n");
+
+ if(!m->cbuf)
+ break;
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ print_method(out, "static ", "\n___real_", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, TRUE, FALSE);
+ print_method_body(m, FALSE, TRUE);
+ /* the outfile line was added above */
+ break;
+ case VIRTUAL_METHOD:
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ if(m->scope==PRIVATE_SCOPE)
+ print_method(out, "static ", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, FALSE, FALSE);
+ else /* PUBLIC, PROTECTED */
+ print_method(out, "", "\n", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, FALSE, FALSE);
+ out_addline_outfile(out);
+ out_printf(out, "{\n"
+ "\t%sClass *klass;\n", typebase);
+ print_preconditions(m);
+ out_printf(out, "\tklass = %s_GET_CLASS(%s);\n\n"
+ "\tif(klass->%s)\n",
+ macrobase, ((FuncArg *)m->args->data)->name,
+ m->id);
+ if(strcmp(m->mtype->name, "void") == 0 &&
+ m->mtype->pointer == NULL) {
+ GList *li;
+ out_printf(out, "\t\t(*klass->%s)(%s",
+ m->id,
+ ((FuncArg *)m->args->data)->name);
+ for(li=m->args->next;li;li=g_list_next(li)) {
+ FuncArg *fa = li->data;
+ out_printf(out, ",%s", fa->name);
+ }
+ out_printf(out, ");\n}\n");
+ } else {
+ GList *li;
+ out_printf(out, "\t\treturn (*klass->%s)(%s",
+ m->id,
+ ((FuncArg *)m->args->data)->name);
+ for(li=m->args->next;li;li=g_list_next(li)) {
+ FuncArg *fa = li->data;
+ out_printf(out, ",%s", fa->name);
+ }
+ out_printf(out, ");\n"
+ "\telse\n"
+ "\t\treturn (");
+ print_type(out, m->mtype, TRUE);
+ if(m->defreturn)
+ out_printf(out, ")(%s);\n}\n", m->defreturn);
+ else if(m->onerror)
+ out_printf(out, ")(%s);\n}\n", m->onerror);
+ else
+ out_printf(out, ")(0);\n}\n");
+ }
+
+ if(!m->cbuf)
+ break;
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ print_method(out, "static ", "\n___real_", "", " ", "", "\n",
+ m, FALSE, FALSE, TRUE, TRUE, FALSE);
+ print_method_body(m, FALSE, TRUE);
+ /* the outfile line was added above */
+ break;
+ case OVERRIDE_METHOD:
+ if(!m->cbuf)
+ break;
+ if(m->line_no > 0)
+ out_addline_infile(out, m->line_no);
+ s = g_strdup_printf("\n___%x_", (guint)m->unique_id);
+ print_method(out, "static ", s, "", " ", "", "\n",
+ m, FALSE, FALSE, FALSE, TRUE, FALSE);
+ g_free(s);
+ out_addline_outfile(out);
+ s = replace_sep(m->otype, '_');
+ gob_strup (s);
+ args = get_arg_names_for_macro(m);
+ if(is_void) {
+ out_printf(out, "#define PARENT_HANDLER(%s) \\\n"
+ "\t{ if(%s_CLASS(parent_class)->%s) \\\n"
+ "\t\t(* %s_CLASS(parent_class)->%s)(%s); }\n",
+ args, s, m->id, s, m->id, args);
+ } else {
+ out_printf(out, "#define PARENT_HANDLER(%s) \\\n"
+ "\t((%s_CLASS(parent_class)->%s)? \\\n"
+ "\t\t(* %s_CLASS(parent_class)->%s)(%s): \\\n"
+ "\t\t(",
+ args, s, m->id, s, m->id, args);
+ out_printf(out, "(");
+ print_type(out, m->mtype, TRUE);
+ out_printf(out, ")%s))\n",
+ m->onerror?m->onerror:"0");
+ }
+ g_free(args);
+ g_free(s);
+ print_method_body(m, TRUE, TRUE);
+ /* the outfile line was added above */
+ out_printf(out, "#undef PARENT_HANDLER\n");
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+open_files(void)
+{
+ char *outfile, *outfileh, *outfileph;
+
+ if ( ! for_cpp)
+ outfile = g_strconcat (fullfilebase, ".c", NULL);
+ else
+ outfile = g_strconcat (fullfilebase, ".cc", NULL);
+ if (no_touch_headers)
+ outfileh = g_strconcat (fullfilebase, ".h#gob#", NULL);
+ else
+ outfileh = g_strconcat (fullfilebase, ".h", NULL);
+
+ if ((privates > 0 || protecteds > 0 ||
+ private_header == PRIVATE_HEADER_ALWAYS) &&
+ private_header != PRIVATE_HEADER_NEVER)
+ outfileph = g_strconcat (fullfilebase, "-private.h", NULL);
+ else
+ outfileph = NULL;
+
+
+ if (no_write) {
+ devnull = fopen ("/dev/null", "w");
+ if (devnull == NULL)
+ error_print (GOB_ERROR, 0, "Cannot open null device");
+ out = devnull;
+ outh = devnull;
+ if (outfileph != NULL)
+ outph = devnull;
+ } else {
+ out = fopen (outfile, "w");
+ if (out == NULL) {
+ error_printf (GOB_ERROR, 0,
+ "Cannot open outfile: %s", outfile);
+ }
+ outh = fopen (outfileh, "w");
+ if (outh == NULL) {
+ error_printf (GOB_ERROR, 0,
+ "Cannot open outfile: %s", outfileh);
+ }
+ if (outfileph != NULL) {
+ outph = fopen (outfileph, "w");
+ if (outph == NULL) {
+ error_printf (GOB_ERROR, 0,
+ "Cannot open outfile: %s",
+ outfileph);
+ }
+ }
+ }
+}
+
+static void
+put_argument_nongnu_wrappers (Class *c)
+{
+ GList *li;
+
+ if (get_properties < 0 && set_properties < 0)
+ return;
+
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ const char *name, *gtktype;
+ gboolean get, set;
+ Type *atype;
+ char *aname;
+ char *cast;
+
+ if (n->type == ARGUMENT_NODE) {
+ Argument *a = (Argument *)n;
+ name = a->name;
+ gtktype = a->gtktype;
+ atype = a->atype;
+ get = a->get != NULL;
+ set = a->set != NULL;
+ } else if (n->type == PROPERTY_NODE) {
+ Property *p = (Property *)n;
+ name = p->name;
+ gtktype = p->gtktype;
+ atype = p->ptype;
+ get = p->get != NULL;
+ set = p->set != NULL;
+ } else {
+ continue;
+ }
+
+ aname = g_strdup (name);
+ gob_strup (aname);
+
+ if (atype != NULL)
+ cast = get_type (atype, TRUE);
+ else
+ cast = g_strdup (get_cast (gtktype, TRUE));
+
+ if (cast != NULL) {
+ if (set)
+ out_printf (outh, "#define %s_PROP_%s(arg) \t"
+ "\"%s\",(%s)(arg)\n",
+ macrobase, aname, name, cast);
+ if (get)
+ out_printf (outh, "#define %s_GET_PROP_%s(arg)\t"
+ "\"%s\",(%s*)(arg)\n",
+ macrobase, aname, name, cast);
+ } else {
+ if(set)
+ out_printf (outh, "#define %s_PROP_%s(arg) \t"
+ "\"%s\",(arg)\n",
+ macrobase, aname, name);
+ if(get)
+ out_printf (outh, "#define %s_GET_PROP_%s(arg)\t"
+ "\"%s\",(arg)\n",
+ macrobase, aname, name);
+ }
+ g_free (cast);
+ g_free (aname);
+ }
+}
+
+static void
+put_argument_gnu_wrappers(Class *c)
+{
+ GList *li;
+
+ if(get_properties < 0 && set_properties < 0)
+ return;
+
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ const char *name, *gtktype;
+ gboolean get, set;
+ Type *atype;
+ char *aname;
+ char *cast;
+
+ if (n->type == ARGUMENT_NODE) {
+ Argument *a = (Argument *)n;
+ name = a->name;
+ gtktype = a->gtktype;
+ atype = a->atype;
+ get = a->get != NULL;
+ set = a->set != NULL;
+ } else if (n->type == PROPERTY_NODE) {
+ Property *p = (Property *)n;
+ name = p->name;
+ gtktype = p->gtktype;
+ atype = p->ptype;
+ get = p->get != NULL;
+ set = p->set != NULL;
+ } else {
+ continue;
+ }
+
+ aname = g_strdup (name);
+ gob_strup (aname);
+
+ if (atype != NULL)
+ cast = get_type (atype, TRUE);
+ else
+ cast = g_strdup (get_cast (gtktype, TRUE));
+
+ if (cast != NULL) {
+ if (set)
+ out_printf (outh, "#define %s_PROP_%s(arg) \t"
+ "\"%s\", __extension__ ({%sz = (arg); z;})\n",
+ macrobase, aname, name, cast);
+ if (get)
+ out_printf (outh, "#define %s_GET_PROP_%s(arg)\t"
+ "\"%s\", __extension__ ({%s*z = (arg); z;})\n",
+ macrobase, aname, name, cast);
+ } else {
+ if (set)
+ out_printf (outh, "#define %s_PROP_%s(arg) \t"
+ "\"%s\",(arg)\n",
+ macrobase, aname, name);
+ if (get)
+ out_printf (outh, "#define %s_GET_PROP_%s(arg)\t"
+ "\"%s\",(arg)\n",
+ macrobase, aname, name);
+ }
+ g_free (cast);
+ g_free (aname);
+ }
+}
+
+static void
+print_ccode_block(CCode *cc)
+{
+ FILE *fp;
+ switch(cc->cctype) {
+ case HT_CCODE:
+ /* HT code is printed exactly like normal header
+ code but is printed before */
+ case H_CCODE:
+ fp = outh;
+ out_printf(fp, "\n");
+ break;
+ case AT_CCODE:
+ /* AT code is printed exactly like normal 'all'
+ code but is printed before */
+ case A_CCODE:
+ if(outph) {
+ out_printf(outph, "\n");
+ out_printf(outph, "%s\n", cc->cbuf);
+ out_addline_infile(outph, cc->line_no);
+ out_addline_outfile(outph);
+ }
+ out_printf(outh, "\n");
+ out_printf(outh, "%s\n", cc->cbuf);
+ fp = out;
+ out_printf(fp, "\n");
+ out_addline_infile(fp, cc->line_no);
+ break;
+ default:
+ case C_CCODE:
+ fp = out;
+ out_printf(fp, "\n");
+ out_addline_infile(fp, cc->line_no);
+ break;
+ case PH_CCODE:
+ if(outph)
+ fp = outph;
+ else
+ fp = out;
+ out_printf(fp, "\n");
+ out_addline_infile(fp, cc->line_no);
+ break;
+ }
+ out_printf(fp, "%s\n", cc->cbuf);
+ if(cc->cctype == C_CCODE ||
+ cc->cctype == A_CCODE ||
+ cc->cctype == AT_CCODE ||
+ cc->cctype == PH_CCODE)
+ out_addline_outfile(fp);
+}
+
+static void
+print_class_block(Class *c)
+{
+ GList *li;
+ char *s;
+ gboolean printed_private = FALSE;
+
+ if(any_special) {
+ out_printf(out, "/* utility types we may need */\n");
+ if(special_array[SPECIAL_2POINTER])
+ out_printf(out, "typedef struct { "
+ "gpointer a; gpointer b; "
+ "} ___twopointertype;\n");
+ if(special_array[SPECIAL_3POINTER])
+ out_printf(out, "typedef struct { "
+ "gpointer a; gpointer b; "
+ "gpointer c; "
+ "} ___threepointertype;\n");
+ if(special_array[SPECIAL_INT_POINTER])
+ out_printf(out, "typedef struct { "
+ "gint a; gpointer b; "
+ "} ___intpointertype;\n");
+ out_printf(out, "\n");
+ }
+
+ out_printf(outh, "\n/*\n"
+ " * Type checking and casting macros\n"
+ " */\n");
+ out_printf(outh, "#define %s\t"
+ "(%s_get_type())\n",
+ macrotype, funcbase);
+ out_printf(outh, "#define %s(obj)\t"
+ "G_TYPE_CHECK_INSTANCE_CAST((obj), %s_get_type(), %s)\n",
+ macrobase, funcbase, typebase);
+ out_printf(outh, "#define %s_CONST(obj)\t"
+ "G_TYPE_CHECK_INSTANCE_CAST((obj), %s_get_type(), %s const)\n",
+ macrobase, funcbase, typebase);
+ out_printf(outh, "#define %s_CLASS(klass)\t"
+ "G_TYPE_CHECK_CLASS_CAST((klass), %s_get_type(), %sClass)\n",
+ macrobase, funcbase, typebase);
+ out_printf(outh, "#define %s(obj)\t"
+ "G_TYPE_CHECK_INSTANCE_TYPE((obj), %s_get_type ())\n\n",
+ macrois, funcbase);
+ out_printf(outh,
+ "#define %s_GET_CLASS(obj)\t"
+ "G_TYPE_INSTANCE_GET_CLASS((obj), %s_get_type(), %sClass)\n",
+ macrobase, funcbase, typebase);
+
+ if ( ! no_self_alias) {
+ out_printf(out, "/* self casting macros */\n");
+ out_printf(out, "#define SELF(x) %s(x)\n", macrobase);
+ out_printf(out, "#define SELF_CONST(x) %s_CONST(x)\n", macrobase);
+ out_printf(out, "#define IS_SELF(x) %s(x)\n", macrois);
+ out_printf(out, "#define TYPE_SELF %s\n", macrotype);
+ out_printf(out, "#define SELF_CLASS(x) %s_CLASS(x)\n\n",
+ macrobase);
+ out_printf(out, "#define SELF_GET_CLASS(x) %s_GET_CLASS(x)\n\n",
+ macrobase);
+
+ out_printf(out, "/* self typedefs */\n");
+ out_printf(out, "typedef %s Self;\n", typebase);
+ out_printf(out, "typedef %sClass SelfClass;\n\n", typebase);
+ }
+
+ if (privates > 0 ||
+ always_private_struct) {
+ out_printf (outh, "\n/* Private structure type */\n");
+ out_printf (outh, "typedef struct _%sPrivate %sPrivate;\n",
+ typebase, typebase);
+ if (privates == 0)
+ out_printf (outh, "/* There are no privates, this "
+ "structure is thus never defined */\n");
+ }
+
+ out_printf (outh, "\n/*\n"
+ " * Main object structure\n"
+ " */\n");
+ s = replace_sep (c->otype, '_');
+ gob_strup (s);
+ out_printf (outh, "#ifndef __TYPEDEF_%s__\n"
+ "#define __TYPEDEF_%s__\n", s, s);
+ g_free (s);
+ out_printf (outh, "typedef struct _%s %s;\n"
+ "#endif\n", typebase, typebase);
+ out_printf (outh, "struct _%s {\n\t%s __parent__;\n",
+ typebase, ptypebase);
+ for (li = c->nodes; li; li=li->next) {
+ static gboolean printed_public = FALSE;
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if(n->type == VARIABLE_NODE &&
+ v->scope == PUBLIC_SCOPE) {
+ if( ! printed_public) {
+ out_printf(outh, "\t/*< public >*/\n");
+ printed_public = TRUE;
+ }
+ put_variable((Variable *)n, outh);
+ }
+ }
+ /* put protecteds always AFTER publics */
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if (n->type == VARIABLE_NODE &&
+ v->scope == PROTECTED_SCOPE) {
+ if ( ! printed_private) {
+ out_printf (outh, "\t/*< private >*/\n");
+ printed_private = TRUE;
+ }
+ put_variable ((Variable *)n, outh);
+ }
+ }
+ if (privates > 0 ||
+ always_private_struct) {
+ if ( ! printed_private)
+ out_printf (outh, "\t/*< private >*/\n");
+ out_printf (outh, "\t%sPrivate *_priv;\n", typebase);
+ }
+ out_printf (outh, "};\n");
+
+ if (privates > 0) {
+ FILE *outfp;
+
+ /* if we are to stick this into the private
+ header, if not stick it directly into the
+ C file */
+ if (outph != NULL)
+ outfp = outph;
+ else
+ outfp = out;
+
+ out_printf (outfp, "struct _%sPrivate {\n",
+ typebase);
+ for(li=c->nodes; li; li=li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if(n->type == VARIABLE_NODE &&
+ v->scope == PRIVATE_SCOPE) {
+ out_addline_infile(outfp, v->line_no);
+ put_variable(v, outfp);
+ }
+ }
+ out_addline_outfile(outfp);
+ out_printf(outfp, "};\n");
+ }
+
+ out_printf(outh, "\n/*\n"
+ " * Class definition\n"
+ " */\n");
+ out_printf(outh, "typedef struct _%sClass %sClass;\n",
+ typebase, typebase);
+ out_printf(outh,
+ "struct _%sClass {\n\t%sClass __parent__;\n",
+ typebase, ptypebase);
+ for(li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ if(n->type == METHOD_NODE)
+ put_vs_method((Method *)n);
+ }
+ /* If BonoboX type class put down the epv */
+ if (c->bonobo_object_class != NULL) {
+ out_printf (outh,
+ "\t/* Bonobo object epv */\n"
+ "\tPOA_%s__epv _epv;\n",
+ c->bonobo_object_class);
+ }
+ /* put class scope variables */
+ for (li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ Variable *v = (Variable *)n;
+ if (n->type == VARIABLE_NODE &&
+ v->scope == CLASS_SCOPE)
+ put_variable ((Variable *)n, outh);
+ }
+ out_printf (outh, "};\n\n");
+
+ out_printf (out, "/* here are local prototypes */\n");
+ if (set_properties > 0) {
+ out_printf (out, "static void ___object_set_property "
+ "(GObject *object, guint property_id, "
+ "const GValue *value, GParamSpec *pspec);\n");
+ }
+ if (get_properties > 0) {
+ out_printf (out, "static void ___object_get_property "
+ "(GObject *object, guint property_id, "
+ "GValue *value, GParamSpec *pspec);\n");
+ }
+
+ out_printf (outh, "\n/*\n"
+ " * Public methods\n"
+ " */\n");
+
+ if ( ! overrode_get_type) {
+ out_printf (outh, "GType\t%s_get_type\t(void);\n", funcbase);
+ }
+
+ for(li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ if(n->type == METHOD_NODE) {
+ put_pub_method((Method *)n);
+ put_prot_method((Method *)n);
+ put_priv_method_prot((Method *)n);
+ }
+ }
+
+ /* this idea is less and less apealing to me */
+ if (signals > 0) {
+ out_printf (outh, "\n/*\n"
+ " * Signal connection wrapper macros\n"
+ " */\n");
+ if( ! no_gnu) {
+ out_printf(outh, "#if defined(__GNUC__) && !defined(__STRICT_ANSI__)\n");
+ put_signal_macros (c, TRUE);
+ out_printf(outh, "#else /* __GNUC__ && !__STRICT_ANSI__ */\n");
+ put_signal_macros (c, FALSE);
+ out_printf(outh, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n");
+ } else {
+ put_signal_macros (c, FALSE);
+ out_printf(outh, "\n");
+ }
+
+ out_printf (out, "\n/*\n"
+ " * Signal connection wrapper macro shortcuts\n"
+ " */\n");
+ put_local_signal_macros (c);
+ out_printf(outh, "\n");
+ }
+
+ /* argument wrapping macros */
+ if(get_properties > 0 || set_properties > 0) {
+ out_printf(outh, "\n/*\n"
+ " * Argument wrapping macros\n"
+ " */\n");
+ if( ! no_gnu) {
+ out_printf(outh, "#if defined(__GNUC__) && !defined(__STRICT_ANSI__)\n");
+ put_argument_gnu_wrappers(c);
+ out_printf(outh, "#else /* __GNUC__ && !__STRICT_ANSI__ */\n");
+ put_argument_nongnu_wrappers(c);
+ out_printf(outh, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n\n");
+ } else {
+ put_argument_nongnu_wrappers(c);
+ }
+ }
+
+ if(signals > 0) {
+ for(li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ if(n->type == METHOD_NODE)
+ add_signal_prots((Method *)n);
+ }
+ }
+
+ add_enums (c);
+
+ if(any_method_to_alias(c)) {
+ out_printf (out, "/* Short form macros */\n");
+ make_method_aliases (c);
+ }
+
+ add_interface_inits (c);
+
+ if ( ! overrode_get_type) {
+ if (c->bonobo_object_class != NULL)
+ add_bonobo_object_get_type ();
+ else
+ add_get_type ();
+ }
+
+ out_printf (out, "/* a macro for creating a new object of our type */\n");
+ out_printf (out,
+ "#define GET_NEW ((%s *)g_object_new(%s_get_type(), NULL))\n\n",
+ typebase, funcbase);
+
+ out_printf (out, "/* a function for creating a new object of our type */\n");
+ out_printf (out, "#include <stdarg.h>\n");
+ out_printf (out,
+ "static %s * GET_NEW_VARG (const char *first, ...)%s;\n"
+ "static %s *\nGET_NEW_VARG (const char *first, ...)\n"
+ "{\n\t%s *ret;\n\tva_list ap;\n"
+ "\tva_start (ap, first);\n"
+ "\tret = (%s *)g_object_new_valist (%s_get_type (), "
+ "first, ap);\n"
+ "\tva_end (ap);\n"
+ "\treturn ret;\n}\n\n",
+ typebase,
+ no_gnu ? "" : " G_GNUC_UNUSED",
+ typebase, typebase, typebase, funcbase);
+
+ if (need_dispose)
+ add_dispose (c);
+
+ if (need_finalize)
+ add_finalize (c);
+
+ add_inits(c);
+
+ if(set_properties > 0) {
+ add_getset_arg(c, TRUE);
+ }
+
+ if(get_properties > 0) {
+ add_getset_arg(c, FALSE);
+ }
+
+ for(li = c->nodes; li != NULL; li = li->next) {
+ Node *n = li->data;
+ if(n->type == METHOD_NODE)
+ put_method((Method *)n);
+ }
+
+ add_bad_hack_to_avoid_unused_warnings(c);
+}
+
+static void
+print_useful_macros(void)
+{
+ int major = 0, minor = 0, pl = 0;
+
+ /* Version stuff */
+ sscanf (VERSION, "%d.%d.%d", &major, &minor, &pl);
+ out_printf (out, "#define GOB_VERSION_MAJOR %d\n", major);
+ out_printf (out, "#define GOB_VERSION_MINOR %d\n", minor);
+ out_printf (out, "#define GOB_VERSION_PATCHLEVEL %d\n\n", pl);
+
+ /* Useful priv macro thingie */
+ /* FIXME: this should be done the same way that priv is, as a var,
+ * not a define */
+ out_printf (out, "#define selfp (self->_priv)\n\n");
+}
+
+static void
+print_more_useful_macros (void)
+{
+ if (no_gnu) {
+ out_printf (out, "#define ___GOB_LIKELY(expr) (expr)\n");
+ out_printf (out, "#define ___GOB_UNLIKELY(expr) (expr)\n");
+ } else {
+ out_printf (out, "#ifdef G_LIKELY\n");
+ out_printf (out, "#define ___GOB_LIKELY(expr) G_LIKELY(expr)\n");
+ out_printf (out, "#define ___GOB_UNLIKELY(expr) G_UNLIKELY(expr)\n");
+ out_printf (out, "#else /* ! G_LIKELY */\n");
+ out_printf (out, "#define ___GOB_LIKELY(expr) (expr)\n");
+ out_printf (out, "#define ___GOB_UNLIKELY(expr) (expr)\n");
+ out_printf (out, "#endif /* G_LIKELY */\n");
+ }
+}
+
+static void
+print_file_comments(void)
+{
+ time_t curtime;
+ time(&curtime);
+ out_printf(outh, "/* Generated by GOB (v%s)"
+ " (do not edit directly) */\n\n", VERSION);
+ if(outph)
+ out_printf(outph, "/* Generated by GOB (v%s)"
+ " (do not edit directly) */\n\n", VERSION);
+ out_printf(out, "/* Generated by GOB (v%s) on %s"
+ " (do not edit directly) */\n\n",
+ VERSION, ctime(&curtime));
+
+ out_printf(out, "/* End world hunger, donate to the World Food Programme, http://www.wfp.org */\n\n");
+}
+
+static void
+print_includes(void)
+{
+ gboolean found_header;
+ char *p;
+
+ /* We may need string.h for memset */
+ if(destructors > 0 &&
+ ! g_list_find_custom(include_files, "string.h", (GCompareFunc)strcmp)) {
+ out_printf(out, "#include <string.h> /* memset() */\n\n");
+ }
+
+ p = g_strconcat(filebase, ".h", NULL);
+ found_header = TRUE;
+ if( ! g_list_find_custom(include_files, p, (GCompareFunc)strcmp)) {
+ out_printf(out, "#include \"%s.h\"\n\n", filebase);
+ found_header = FALSE;
+ }
+ g_free(p);
+
+ /* if we are creating a private header see if it was included */
+ if(outph) {
+ p = g_strconcat(filebase, "-private.h", NULL);
+ if( ! g_list_find_custom(include_files, p,
+ (GCompareFunc)strcmp)) {
+ out_printf(out, "#include \"%s-private.h\"\n\n",
+ filebase);
+ if(found_header)
+ error_printf(GOB_WARN, 0,
+ "Implicit private header include "
+ "added to top of\n"
+ "\tsource file, while public "
+ "header is at a custom location, "
+ "you should\n"
+ "\texplicitly include "
+ "the private header below the "
+ "public one.");