extern FILE * yyin;
extern Node *class;
extern GList *nodes;
+extern GList *enums;
extern GList *include_files;
static gboolean special_array[SPECIAL_LAST] = {0};
static gboolean any_special = FALSE;
-static gboolean need_shutdown = FALSE;
-static Method * shutdown_handler = NULL;
+static gboolean need_dispose = FALSE;
+static Method * dispose_handler = NULL;
static gboolean need_finalize = FALSE;
static Method * finalize_handler = NULL;
gboolean no_self_alias = FALSE;
gboolean always_private_struct = FALSE;
+gboolean use_m4 = FALSE; /* preprocess sources with m4 */
+gboolean use_m4_clean = FALSE; /* preprocess sources with m4, no m4 flags */
+char *m4_commandline = NULL;
+#define M4_INCLUDE_DIR PKGDATADIR "/m4"
+#define M4_BASE_FILENAME "gobm4.m4"
+#define M4_FLAGS "-P -s -I" M4_INCLUDE_DIR " -DGOBM4_GOB_VERSION=" VERSION " " M4_BASE_FILENAME
+#define M4_COMMANDLINE "m4"
+
int method_unique_id = 1;
static void
ptypebase = remove_sep (((Class *)class)->ptype);
}
-static char *
-get_type (const Type *t, gboolean postfix_to_stars)
-{
- char *s;
- int i;
- int extra;
- GString *gs;
-
- s = remove_sep(t->name);
- gs = g_string_new(s);
- g_free(s);
-
- extra = 0;
- if (postfix_to_stars) {
- const char *p;
- /*XXX: this is ugly perhaps we can do this whole postfix thing
- in a nicer way, we just count the number of '[' s and from
- that we deduce the number of dimensions, so that we can print
- that many stars */
- for (p = t->postfix; p && *p; p++)
- if(*p == '[') extra++;
- }
- g_string_append_c(gs, ' ');
-
- if (t->pointer != NULL) {
- g_string_append (gs, t->pointer);
- for (i=0; i < extra; i++)
- g_string_append_c (gs, '*');
- g_string_append_c (gs, ' ');
- }
-
- s = gs->str;
- g_string_free (gs, FALSE);
- return s;
-}
-
static char *
get_gtk_doc (const char *id)
{
static void
put_signal_macro (const Method *m, gboolean gnu)
{
- char *id;
-
if(m->method != SIGNAL_LAST_METHOD &&
m->method != SIGNAL_FIRST_METHOD)
return;
- id = g_strdup (m->id);
- g_strup (id);
-
if ( ! gnu) {
- out_printf (outh, "#define %s_SIGNAL_%s(func)\t"
- "\"%s\",(GCallback)(func)\n",
- macrobase, id, m->id);
+ /* connect */
+ out_printf (outh, "#define %s_connect__%s(object,func,data)\t"
+ "g_signal_connect(%s(object),\"%s\","
+ "(GCallback)(func),(data))\n",
+ funcbase, m->id, macrobase, m->id);
+
+ /* connect_after */
+ out_printf (outh, "#define %s_connect_after__%s(object,func,data)\t"
+ "g_signal_connect_after(%s(object),\"%s\","
+ "(GCallback)(func),(data))\n",
+ funcbase, m->id, macrobase, m->id);
+
+ /* connect_data */
+ out_printf (outh, "#define %s_connect_data__%s"
+ "(object,func,data,destroy_data,flags)\t"
+ "g_signal_connect_data(%s(object),\"%s\","
+ "(GCallback)(func),(data),(destroy_data),(GConnectFlags)(flags))\n",
+ funcbase, m->id, macrobase, m->id);
} else {
- out_printf (outh, "#define %s_SIGNAL_%s(func)\t"
- "\"%s\",(GCallback)(({",
- macrobase, id, m->id);
- print_method (outh, "", "(* ___", "", ") ", ", gpointer data ",
- " = func; ", m, FALSE, TRUE, TRUE);
- out_printf (outh, "___%s; }))\n", m->id);
-
+ /* connect */
+ out_printf (outh, "#define %s_connect__%s(object,func,data)\t"
+ "g_signal_connect("
+ "%s(({%s *___object = (object); ___object; })),"
+ "\"%s\","
+ "(GCallback)({",
+ funcbase, m->id, macrobase, typebase, m->id);
+ print_method (outh, "", "(* ___", "", ") ", ", gpointer ___data ",
+ " = (func); ", m, FALSE, TRUE, TRUE);
+ out_printf (outh, "___%s; }), (data))\n", m->id);
+
+ /* connect_after */
+ out_printf (outh, "#define %s_connect_after__%s(object,func,data)\t"
+ "g_signal_connect_after("
+ "%s(({%s *___object = (object); ___object; })),"
+ "\"%s\","
+ "(GCallback)({",
+ funcbase, m->id, macrobase, typebase, m->id);
+ print_method (outh, "", "(* ___", "", ") ", ", gpointer ___data ",
+ " = (func); ", m, FALSE, TRUE, TRUE);
+ out_printf (outh, "___%s; }), (data))\n", m->id);
+
+ /* connect_data */
+ out_printf (outh, "#define %s_connect_data__%s"
+ "(object,func,data,destroy_data,flags)\t"
+ "g_signal_connect_data("
+ "%s(({%s *___object = (object); ___object; })),"
+ "\"%s\","
+ "(GCallback)({",
+ funcbase, m->id, macrobase, typebase, m->id);
+ print_method (outh, "", "(* ___", "", ") ", ", gpointer ___data ",
+ " = (func); ", m, FALSE, TRUE, TRUE);
+ out_printf (outh, "___%s; }), (data), (destroy_data), (GConnectFlags)(flags))\n", m->id);
}
- g_free (id);
}
static void
}
}
+static void
+put_local_signal_macro (const Method *m)
+{
+ if(m->method != SIGNAL_LAST_METHOD &&
+ m->method != SIGNAL_FIRST_METHOD)
+ return;
+
+ /* connect */
+ out_printf (out, "#define self_connect__%s(object,func,data)\t"
+ "%s_connect__%s((object),(func),(data))\n",
+ m->id, funcbase, m->id);
+
+ /* connect_after */
+ out_printf (out, "#define self_connect_after__%s(object,func,data)\t"
+ "%s_connect_after__%s((object),(func),(data))\n",
+ m->id, funcbase, m->id);
+
+ /* connect_data */
+ out_printf (out, "#define self_connect_data__%s(object,func,data,destroy_data,flags)\t"
+ "%s_connect_data__%s((object),(func),(data),(destroy_data),(flags))\n",
+ m->id, funcbase, m->id);
+}
+
+static void
+put_local_signal_macros (const Class *c)
+{
+ const GList *li;
+
+ if (signals < 0)
+ return;
+
+ for (li = c->nodes; li != NULL; li = li->next) {
+ const Node *n = li->data;
+ if (n->type == METHOD_NODE)
+ put_local_signal_macro ((Method *)n);
+ }
+}
+
static void
put_prot_method(const Method *m)
}
static GList *
-make_func_arg(char *typename, int is_class, char *name)
+make_func_arg (const char *typename, gboolean is_class, const char *name)
{
Node *node;
Node *type;
char *tn;
- if(is_class)
- tn = g_strconcat(typename, ":Class", NULL);
+ if (is_class)
+ tn = g_strconcat (typename, ":Class", NULL);
else
- tn = g_strdup(typename);
+ tn = g_strdup (typename);
type = node_new (TYPE_NODE,
"name:steal", tn,
NULL);
node = node_new (FUNCARG_NODE,
"atype:steal", (Type *)type,
- "name:steal", name,
+ "name", name,
NULL);
- return g_list_prepend(NULL, node);
+ return g_list_prepend (NULL, node);
}
static void
"method", CLASS_INIT_METHOD,
"mtype:steal", type,
"id", "class_init",
- "args:steal", make_func_arg (cl->otype, TRUE, g_strdup("c")),
+ "args:steal", make_func_arg (cl->otype,
+ TRUE /* is_class */,
+ "c" /* name */),
"unique_id", method_unique_id++,
NULL);
cl->nodes = g_list_prepend(cl->nodes, node);
"method", INIT_METHOD,
"mtype:steal", type,
"id", "init",
- "args:steal", make_func_arg (cl->otype, TRUE, g_strdup("o")),
+ "args:steal", make_func_arg (cl->otype,
+ FALSE /* is_class */,
+ "o" /* name */),
"unique_id", method_unique_id++,
NULL);
cl->nodes = g_list_prepend(cl->nodes, node);
}
static void
-find_shutdown(Class *cl)
+find_dispose(Class *cl)
{
GList *li;
- shutdown_handler = NULL;
+ dispose_handler = NULL;
for(li=cl->nodes;li;li=g_list_next(li)) {
Node *n = li->data;
if(n->type == METHOD_NODE) {
Method *m = (Method *)n;
if(m->method == OVERRIDE_METHOD &&
- strcmp(m->id, "shutdown")==0) {
+ strcmp(m->id, "dispose")==0) {
if(strcmp(m->otype, "G:Object") != 0) {
error_print(GOB_ERROR, m->line_no,
- "shutdown method override "
+ "dispose method override "
"of class other then "
"G:Object");
}
if(g_list_length(m->args) != 1) {
error_print(GOB_ERROR, m->line_no,
- "shutdown method override "
+ "dispose method override "
"with more then one "
"parameter");
}
- shutdown_handler = m;
+ dispose_handler = m;
break;
}
}
out_printf(out, "static %sClass *parent_class = NULL;\n\n", ptypebase);
}
+static void
+add_interface_methods (Class *c, const char *interface)
+{
+ 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 ||
+ m->interface == NULL ||
+ strcmp (m->interface, interface) != 0)
+ continue;
+
+ 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, "\tiface->%s = self_%s;\n",
+ m->id, m->id);
+ }
+ if (added_line)
+ out_addline_outfile (out);
+}
+
+static void
+add_interface_inits (Class *c)
+{
+ GList *li;
+
+ if (c->interfaces == NULL)
+ return;
+
+ out_printf(out, "\n");
+
+ for (li = c->interfaces; li != NULL; li = li->next) {
+ const char *interface = li->data;
+ const char *end;
+ char *name = replace_sep (interface, '_');
+ char *type = remove_sep (interface);
+
+ /* EEEK! evil, we should have some sort of option
+ * to force this for arbitrary interfaces, since
+ * some are Class and some are Iface. Glib is shite
+ * in consistency. */
+ if (strcmp (type, "GtkEditable") == 0 ||
+ strcmp (type, "GTypePlugin") == 0)
+ end = "Class";
+ else
+ /* We'll assume Iface is the standard ending */
+ end = "Iface";
+
+ out_printf (out, "\nstatic void\n"
+ "___%s_init (%s%s *iface)\n"
+ "{\n",
+ name, type, end);
+
+ add_interface_methods (c, interface);
+
+ out_printf (out, "}\n\n");
+
+ g_free (name);
+ g_free (type);
+ }
+}
+
+static void
+add_interface_infos (void)
+{
+ GList *li;
+ for (li = ((Class *)class)->interfaces;
+ li != NULL;
+ li = li->next) {
+ char *name = replace_sep (li->data, '_');
+ out_printf (out,
+ "\t\tstatic const GInterfaceInfo %s_info = {\n"
+ "\t\t\t(GInterfaceInitFunc) ___%s_init,\n"
+ "\t\t\tNULL,\n"
+ "\t\t\tNULL\n"
+ "\t\t};\n\n",
+ name, name);
+ g_free (name);
+ }
+}
+
+static void
+add_interfaces (void)
+{
+ GList *li;
+ for (li = ((Class *)class)->interfaces;
+ li != NULL;
+ li = li->next) {
+ char *name = replace_sep (li->data, '_');
+ char *type = make_pre_macro (li->data, "TYPE");
+
+ out_printf (out,
+ "\t\tg_type_add_interface_static (type,\n"
+ "\t\t\t%s,\n"
+ "\t\t\t&%s_info);\n",
+ type,
+ name);
+
+ g_free (type);
+ g_free (name);
+ }
+}
+
static void
add_get_type(void)
{
"\t\t\tsizeof (%s),\n"
"\t\t\t0 /* n_preallocs */,\n"
"\t\t\t(GInstanceInitFunc) %s_init,\n"
- "\t\t};\n\n"
- "\t\ttype = g_type_register_static (%s, \"%s\", &info, (GTypeFlags)0);\n",
- funcbase, typebase, funcbase, typebase, funcbase,
- pmacrotype, typebase);
+ "\t\t};\n\n",
+ funcbase, typebase, funcbase, typebase, funcbase);
+
+ add_interface_infos ();
+
+ out_printf (out,
+ "\t\ttype = g_type_register_static (%s, \"%s\", &info, (GTypeFlags)0);\n",
+ pmacrotype, typebase);
+
+ add_interfaces ();
+
/*
if(chunk_size) {
out_printf(out,
}
static void
-add_bonobo_x_get_type (void)
+add_bonobo_object_get_type (void)
{
/* char *chunk_size = ((Class*)class)->chunk_size; */
+ /* _vicious_ spanks seth with a rusty nail
+ out_printf(out,
+ "\n#warning \"Bonobo isn't fully ported to glib 2.0 and "
+ "gob2 doesn't officially support it yet. It'd be safer "
+ "and a lot more fun to blow goats.\"\n");
+ */
+
+ out_printf (out,
+ "GType\n"
+ "%s_get_type (void)\n" /* 1 */
+ "{\n"
+ "\tstatic GType type = 0;\n\n"
+ "\tif (type == 0) {\n"
+ "\t\tstatic const GTypeInfo info = {\n"
+ "\t\t\tsizeof (%sClass),\n" /* 2 */
+ "\t\t\t(GBaseInitFunc) NULL,\n"
+ "\t\t\t(GBaseFinalizeFunc) NULL,\n"
+ "\t\t\t(GClassInitFunc) %s_class_init,\n" /* 3 */
+ "\t\t\tNULL, /* class_finalize */\n"
+ "\t\t\tNULL, /* class_data */\n"
+ "\t\t\tsizeof (%s),\n" /* 4 */
+ "\t\t\t0, /* n_preallocs */\n"
+ "\t\t\t(GInstanceInitFunc) %s_init,\n" /* 5 */
+ "\t\t\tNULL\n"
+ "\t\t};\n\n",
+ funcbase /* 1 */,
+ typebase /* 2 */,
+ funcbase /* 3 */,
+ typebase /* 4 */,
+ funcbase /* 5 */);
+
+ add_interface_infos ();
+
+ out_printf (out,
+ "\t\ttype = bonobo_type_unique (\n"
+ "\t\t\tBONOBO_OBJECT_TYPE,\n"
+ "\t\t\tPOA_%s__init, NULL,\n" /* 1 */
+ "\t\t\tG_STRUCT_OFFSET (%sClass, _epv),\n" /* 2 */
+ "\t\t\t&info, \"%s\");\n", /* 3 */
+ ((Class*)class)->bonobo_object_class /* 1 */,
+ typebase /* 2 */,
+ typebase /* 3 */);
+
+ add_interfaces ();
- out_printf(out,
- "\n#error \"BonoboX isn't ported to glib 2.0 and "
- "gob2 doesn't support it yet\"");
-
- out_printf(out,
- "GtkType\n"
- "%s_get_type (void)\n"
- "{\n"
- "\tstatic GtkType type = 0;\n\n"
- "\tif (type == 0) {\n"
- "\t\tstatic const GtkTypeInfo info = {\n"
- "\t\t\t\"%s\",\n"
- "\t\t\tsizeof (%s),\n"
- "\t\t\tsizeof (%sClass),\n"
- "\t\t\t(GtkClassInitFunc) %s_class_init,\n"
- "\t\t\t(GtkObjectInitFunc) %s_init,\n"
- "\t\t\t/* reserved_1 */ NULL,\n"
- "\t\t\t/* reserved_2 */ NULL,\n"
- "\t\t\t(GtkClassInitFunc) NULL\n"
- "\t\t};\n\n"
- "\t\ttype = bonobo_x_type_unique\n"
- "\t\t\t(%s_get_type (),\n"
- "\t\t\tPOA_%s__init, NULL,\n"
- "\t\t\tGTK_STRUCT_OFFSET (%sClass, _epv),\n"
- "\t\t\t&info);\n",
- funcbase, typebase, typebase, typebase,
- funcbase, funcbase, pfuncbase,
- ((Class*)class)->bonobo_x_class,
- typebase);
/*if(chunk_size) {
out_printf(out,
"#if %s > 0\n"
s = replace_sep (m->otype, '_');
g_strdown (s);
- if (need_shutdown &&
- shutdown_handler != NULL &&
- strcmp (m->id, "shutdown") == 0)
- out_printf (out, "\tg_object_class->shutdown "
- "= ___shutdown;\n");
+ if (need_dispose &&
+ dispose_handler != NULL &&
+ strcmp (m->id, "dispose") == 0)
+ out_printf (out, "\tg_object_class->dispose "
+ "= ___dispose;\n");
else if (need_finalize &&
finalize_handler &&
strcmp(m->id, "finalize") == 0)
#define value_for_print(str, alt) (str != NULL ? str : alt)
+static char *
+make_me_type (const char *type, const char *alt)
+{
+ if (type == NULL)
+ return g_strdup (alt);
+ /* HACK! just in case someone made this
+ * work with 2.0.0 by using the TYPE
+ * macro directly */
+ if ((strstr (type, "_TYPE_") != NULL ||
+ strstr (type, "TYPE_") == type) &&
+ strchr (type, ':') == NULL)
+ return g_strdup (type);
+ return make_pre_macro (type, "TYPE");
+}
+
static void
make_property (Property *p)
{
g_string_append (flags, ")");
- if (strcmp (p->gtktype, "CHAR") == 0)
+ 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"
value_for_print (p->maximum, "127"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "UCHAR") == 0)
+ } 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"
value_for_print (p->maximum, "0xFF"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "BOOLEAN") == 0)
+ } 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"
value_for_print (p->blurb, "NULL"),
value_for_print (p->default_value, "FALSE"),
flags->str);
- else if (strcmp (p->gtktype, "INT") == 0)
+ } 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"
value_for_print (p->maximum, "G_MAXINT"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "UINT") == 0)
+ } 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"
value_for_print (p->maximum, "G_MAXUINT"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "LONG") == 0)
+ } 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"
value_for_print (p->maximum, "G_MAXLONG"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "ULONG") == 0)
+ } 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"
value_for_print (p->maximum, "G_MAXULONG"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "UNICHAR") == 0)
+ } 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"
value_for_print (p->blurb, "NULL"),
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "ENUM") == 0)
+ } 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"
p->name,
value_for_print (p->nick, "NULL"),
value_for_print (p->blurb, "NULL"),
- value_for_print (p->extra_gtktype, "G_TYPE_ENUM"),
+ type,
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "FLAGS") == 0)
+ 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"
p->name,
value_for_print (p->nick, "NULL"),
value_for_print (p->blurb, "NULL"),
- value_for_print (p->extra_gtktype, "G_TYPE_FLAGS"),
+ type,
value_for_print (p->default_value, "0"),
flags->str);
- else if (strcmp (p->gtktype, "FLOAT") == 0)
+ 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"
value_for_print (p->maximum, "G_MAXFLOAT"),
value_for_print (p->default_value, "0.0"),
flags->str);
- else if (strcmp (p->gtktype, "DOUBLE") == 0)
+ } 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"
value_for_print (p->maximum, "G_MAXDOUBLE"),
value_for_print (p->default_value, "0.0"),
flags->str);
- else if (strcmp (p->gtktype, "STRING") == 0)
+ } 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"
value_for_print (p->blurb, "NULL"),
value_for_print (p->default_value, "NULL"),
flags->str);
- else if (strcmp (p->gtktype, "PARAM") == 0)
+ } 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"
p->name,
value_for_print (p->nick, "NULL"),
value_for_print (p->blurb, "NULL"),
- value_for_print (p->extra_gtktype, "G_TYPE_PARAM"),
+ type,
flags->str);
- else if (strcmp (p->gtktype, "BOXED") == 0)
+ 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"
p->name,
value_for_print (p->nick, "NULL"),
value_for_print (p->blurb, "NULL"),
- value_for_print (p->extra_gtktype, "G_TYPE_BOXED"),
+ type,
flags->str);
- else if (strcmp (p->gtktype, "POINTER") == 0)
+ 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"
value_for_print (p->blurb, "NULL"),
flags->str);
/* FIXME: VALUE_ARRAY */
- else if (strcmp (p->gtktype, "CLOSURE") == 0)
+ } 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"
value_for_print (p->nick, "NULL"),
value_for_print (p->blurb, "NULL"),
flags->str);
- else if (strcmp (p->gtktype, "OBJECT") == 0)
+ } 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"
p->name,
value_for_print (p->nick, "NULL"),
value_for_print (p->blurb, "NULL"),
- value_for_print (p->extra_gtktype, "G_TYPE_OBJECT"),
+ type,
flags->str);
- else
+ 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);
g_strup (s);
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");
make_argument ((Argument *)n);
}
out_printf(out, " }\n");
-
- 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");
}
static void
}
static void
-add_shutdown (Class *c)
+add_dispose (Class *c)
{
out_printf(out, "\nstatic void\n"
- "___shutdown (GObject *obj_self)\n"
+ "___dispose (GObject *obj_self)\n"
"{\n");
out_printf(out,
- "#define __GOB_FUNCTION__ \"%s::shutdown\"\n",
+ "#define __GOB_FUNCTION__ \"%s::dispose\"\n",
c->otype);
if (unreftors > 0) {
typebase, macrobase);
}
- if (shutdown_handler != NULL) {
+ if (dispose_handler != NULL) {
/* so we get possible bad argument warning */
- if (shutdown_handler->line_no > 0)
- out_addline_infile (out, shutdown_handler->line_no);
- out_printf (out, "\t___%x_%s_shutdown(obj_self);\n",
- (guint)shutdown_handler->unique_id, funcbase);
- if (shutdown_handler->line_no > 0)
+ 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)->shutdown) \\\n"
- "\t\t(* G_OBJECT_CLASS (parent_class)->shutdown) (obj_self);\n");
+ "\tif (G_OBJECT_CLASS (parent_class)->dispose) \\\n"
+ "\t\t(* G_OBJECT_CLASS (parent_class)->dispose) (obj_self);\n");
}
if (unreftors > 0) {
}
static void
-make_bonobo_x_epv (Class *c, const char *classname)
+make_bonobo_object_epv (Class *c, const char *classname)
{
GList *li;
gboolean added_line = FALSE;
m->method == OVERRIDE_METHOD)
continue;
- if (m->bonobo_x_func) {
+ if (m->bonobo_object_func) {
if(m->line_no > 0) {
out_addline_infile(out, m->line_no);
added_line = TRUE;
out_addline_outfile(out);
added_line = FALSE;
}
- out_printf (out, "\t%s->_epv.%s = %s;\n",
+ out_printf (out, "\t%s->_epv.%s = self_%s;\n",
classname, m->id, m->id);
}
}
if (set_properties > 0 ||
get_properties > 0 ||
signals > 0 ||
- need_shutdown ||
+ need_dispose ||
need_finalize) {
out_printf(out,
"\tGObjectClass *"
/* if there are no handlers for these things, we
* need to set them up here */
- if(need_shutdown && !shutdown_handler)
- out_printf(out, "\tg_object_class->shutdown "
- "= ___shutdown;\n");
+ 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_x_class != NULL) {
- make_bonobo_x_epv (c, ((FuncArg *)m->args->data)->name);
+ if (c->bonobo_object_class != NULL) {
+ make_bonobo_object_epv (c, ((FuncArg *)m->args->data)->name);
}
} else
continue;
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",
+ out_printf (out, "\t\tg_value_set_%s (VAL, G_OBJECT (ARG));\n",
the_type_lower);
else
out_printf (out, "\t\t"
{
GList *li;
GList *ali;
- for (ali = m->gtktypes->next, li=m->args->next;
+ 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) {
+ 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);
the we know all the types */
g_assert (cast != NULL);
- out_printf (out, ",\n\t\t(%s)%s", cast,
- fa->name);
+ 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);
+
+ set_func = g_strdup_printf ("g_value_set%s_%s",
+ do_static ? "_static" : "",
+ (char *)ali->data);
+ g_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);
}
}
else /* PUBLIC, PROTECTED */
print_method(out, "", "\n", "", " ", "", "\n",
m, FALSE, FALSE, TRUE);
- out_addline_outfile(out);
- out_printf(out, "{\n");
- s = g_strdup(m->id);
- g_strup(s);
- if(strcmp(m->mtype->name, "void") == 0 &&
- m->mtype->pointer == NULL) {
- print_preconditions(m);
- if(((FuncArg *)m->args->data)->name)
- out_printf(out, "\tg_signal_emit (G_OBJECT (%s),\n"
- "\t\tobject_signals[%s_SIGNAL], 0",
- ((FuncArg *)m->args->data)->name, s);
- put_signal_args (m);
- out_printf(out, ");\n}\n");
- } else {
- out_printf(out, "\t");
- print_type(out, m->mtype, TRUE);
- out_printf(out, "return_val = (");
- print_type(out, m->mtype, TRUE);
- if(m->defreturn)
- out_printf(out, ")(%s);\n", m->defreturn);
- else if(m->onerror)
- out_printf(out, ")(%s);\n", m->onerror);
- else
- out_printf(out, ")(0);\n");
- print_preconditions(m);
- out_printf(out, "\tg_signal_emit (G_OBJECT (%s),\n"
- "\t\tobject_signals[%s_SIGNAL], 0",
- ((FuncArg *)m->args->data)->name, s);
- put_signal_args(m);
- out_printf(out, ",\n\t\t&return_val);\n"
- "\treturn return_val;\n}\n");
+ out_addline_outfile (out);
+
+ out_printf (out, "{\n");
+
+ out_printf (out,
+ "\tGValue ___param_values[%d];\n"
+ "\tGValue ___return_val = {0};\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);
+
+ set_func = g_strdup_printf ("g_value_set%s_%s",
+ do_static ? "_static" : "",
+ (char *)m->gtktypes->data);
+ g_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);
+ g_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);
+
+ if (strcmp (m->gtktypes->data, "NONE") != 0) {
+ char *cast = g_strdup (get_cast (m->gtktypes->data, FALSE));
+ char *getfunc = g_strdup_printf ("g_value_get_%s",
+ (char *)m->gtktypes->data);
+ g_strdown (getfunc);
+
+ if (cast == NULL)
+ cast = get_type (m->mtype, TRUE);
+
+ out_printf (out, "\n\treturn (%s) %s (&___return_val);\n",
+ cast, getfunc);
+
+ g_free (cast);
+ g_free (getfunc);
}
+ out_printf(out, "}\n");
if(!m->cbuf)
break;
put_vs_method((Method *)n);
}
/* If BonoboX type class put down the epv */
- if (c->bonobo_x_class != NULL) {
+ if (c->bonobo_object_class != NULL) {
out_printf (outh,
"\t/* Bonobo object epv */\n"
"\tPOA_%s__epv _epv;\n",
- c->bonobo_x_class);
+ c->bonobo_object_class);
}
/* put class scope variables */
for (li = c->nodes; li != NULL; li = li->next) {
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\n");
+ 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 */
}
}
- add_enums(c);
-
- if ( ! overrode_get_type) {
- if (c->bonobo_x_class != NULL)
- add_bonobo_x_get_type ();
- else
- add_get_type ();
- }
+ add_enums (c);
if(any_method_to_alias(c)) {
if( ! no_gnu) {
make_method_nongnu_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",
no_gnu ? "" : " G_GNUC_UNUSED",
typebase, typebase, typebase, funcbase);
- if (need_shutdown)
- add_shutdown (c);
+ if (need_dispose)
+ add_dispose (c);
if (need_finalize)
add_finalize (c);
GList *li;
/* mandatory includes */
- out_printf(outh, "#include <glib.h>\n");
- out_printf(outh, "#include <gobject/gobject.h>\n");
- out_printf(outh, "#include <gobject/gvaluetypes.h>\n");
- out_printf(outh, "#include <gobject/genums.h>\n");
- out_printf(outh, "#include <gobject/gboxed.h>\n");
- out_printf(outh, "#include <gobject/gparamspecs.h>\n\n");
+ out_printf (outh, "#include <glib.h>\n");
+ out_printf (outh, "#include <glib-object.h>\n");
/* print the HT_CCODE blocks */
for (li = nodes; li != NULL; li = li->next) {
Node *node = li->data;
- if(node->type == CCODE_NODE) {
+ if (node->type == CCODE_NODE) {
CCode *cc = (CCode *)node;
- if(cc->cctype == HT_CCODE)
- print_ccode_block((CCode *)node);
+ if (cc->cctype == HT_CCODE)
+ print_ccode_block ((CCode *)node);
}
}
}
+static void
+print_enum (EnumDef *enode)
+{
+ GList *li;
+ char *funcprefix;
+ char *type;
+ char *str;
+
+ funcprefix = replace_sep (enode->etype, '_');
+ g_strdown (funcprefix);
+ out_printf (out, "static const GEnumValue _%s_values[] = {\n",
+ funcprefix);
+ type = remove_sep (enode->etype);
+
+ out_printf (outh, "\ntypedef enum {\n");
+
+ for (li = enode->values; li != NULL; li = li->next) {
+ EnumValue *value = li->data;
+ char *p;
+ char *sname = g_strdown (g_strdup (value->name));
+
+ while ((p = strchr (sname, '_')) != NULL)
+ *p = '-';
+
+ out_printf (outh, "\t%s_%s", enode->prefix, value->name);
+ if (value->value != NULL)
+ out_printf (outh, " = %s", value->value);
+ if (li->next != NULL)
+ out_printf (outh, ",\n");
+ else
+ out_printf (outh, "\n");
+
+ out_printf (out, "\t{ %s_%s, \"%s_%s\", \"%s\" },\n",
+ enode->prefix, value->name,
+ enode->prefix, value->name,
+ sname);
+
+ g_free (sname);
+ }
+
+ out_printf (out, "\t{ 0, NULL, NULL }\n};\n\n");
+
+ out_printf (outh, "} %s;\n", type);
+
+ str = make_pre_macro (enode->etype, "TYPE");
+ out_printf (outh, "#define %s ", str);
+ g_free (str);
+
+ out_printf (outh, "%s_get_type()\n", funcprefix);
+ out_printf (outh, "GType %s_get_type (void);\n\n", funcprefix);
+
+ out_printf (out,
+ "GType\n%s_get_type (void)\n"
+ "{\n"
+ "\tstatic GType type = 0;\n"
+ "\tif (type == 0)\n"
+ "\t\ttype = g_enum_register_static (\"%s\", _%s_values);\n"
+ "\treturn type;\n"
+ "}\n\n",
+ funcprefix, type, funcprefix);
+
+ g_free (funcprefix);
+ g_free (type);
+}
+
+static void
+print_flags (Flags *fnode)
+{
+ GList *li;
+ char *funcprefix;
+ char *type;
+ char *str;
+ int i;
+
+ funcprefix = replace_sep (fnode->ftype, '_');
+ g_strdown (funcprefix);
+ out_printf (out, "static const GFlagsValue _%s_values[] = {\n",
+ funcprefix);
+ type = remove_sep (fnode->ftype);
+
+ out_printf (outh, "\ntypedef enum {\n");
+
+ for (i = 0, li = fnode->values; li != NULL; i++, li = li->next) {
+ const char *name = li->data;
+ char *p;
+ char *sname = g_strdown (g_strdup (name));
+
+ while ((p = strchr (sname, '_')) != NULL)
+ *p = '-';
+
+ out_printf (outh, "\t%s_%s = 1<<%d",
+ fnode->prefix, name, i);
+ if (li->next != NULL)
+ out_printf (outh, ",\n");
+ else
+ out_printf (outh, "\n");
+
+ out_printf (out, "\t{ %s_%s, \"%s_%s\", \"%s\" },\n",
+ fnode->prefix, name,
+ fnode->prefix, name,
+ sname);
+
+ g_free (sname);
+ }
+
+ out_printf (out, "\t{ 0, NULL, NULL }\n};\n\n");
+
+ out_printf (outh, "} %s;\n", type);
+
+ str = make_pre_macro (fnode->ftype, "TYPE");
+ out_printf (outh, "#define %s ", str);
+ g_free (str);
+
+ out_printf (outh, "%s_get_type()\n", funcprefix);
+ out_printf (outh, "GType %s_get_type (void);\n\n", funcprefix);
+
+ out_printf (out,
+ "GType\n%s_get_type (void)\n"
+ "{\n"
+ "\tstatic GType type = 0;\n"
+ "\tif (type == 0)\n"
+ "\t\ttype = g_flags_register_static (\"%s\", _%s_values);\n"
+ "\treturn type;\n"
+ "}\n\n",
+ funcprefix, type, funcprefix);
+
+ g_free (funcprefix);
+ g_free (type);
+}
+
+static void
+print_error (Error *enode)
+{
+ GList *li;
+ char *funcprefix;
+ char *type;
+ char *str;
+
+ funcprefix = replace_sep (enode->etype, '_');
+ g_strdown (funcprefix);
+ out_printf (out, "static const GEnumValue _%s_values[] = {\n",
+ funcprefix);
+ type = remove_sep (enode->etype);
+
+ out_printf (outh, "\ntypedef enum {\n");
+
+ for (li = enode->values; li != NULL; li = li->next) {
+ const char *name = li->data;
+ char *p;
+ char *sname = g_strdown (g_strdup (name));
+
+ while ((p = strchr (sname, '_')) != NULL)
+ *p = '-';
+
+ out_printf (outh, "\t%s_%s", enode->prefix, name);
+ if (li->next != NULL)
+ out_printf (outh, ",\n");
+ else
+ out_printf (outh, "\n");
+
+ out_printf (out, "\t{ %s_%s, \"%s_%s\", \"%s\" },\n",
+ enode->prefix, name,
+ enode->prefix, name,
+ sname);
+
+ g_free (sname);
+ }
+
+ out_printf (out, "\t{ 0, NULL, NULL }\n};\n\n");
+
+ out_printf (outh, "} %s;\n", type);
+
+ str = make_pre_macro (enode->etype, "TYPE");
+ out_printf (outh, "#define %s ", str);
+ g_free (str);
+
+ out_printf (outh, "%s_get_type ()\n", funcprefix);
+ out_printf (outh, "GType %s_get_type (void);\n\n", funcprefix);
+
+ out_printf (out,
+ "GType\n%s_get_type (void)\n"
+ "{\n"
+ "\tstatic GType type = 0;\n"
+ "\tif (type == 0)\n"
+ "\t\ttype = g_enum_register_static (\"%s\", _%s_values);\n"
+ "\treturn type;\n"
+ "}\n\n",
+ funcprefix, type, funcprefix);
+
+ out_printf (outh, "#define %s %s_quark ()\n", enode->prefix, funcprefix);
+ out_printf (outh, "GQuark %s_quark (void);\n\n", funcprefix);
+
+ str = replace_sep (enode->etype, '-');
+ g_strdown (str);
+
+ out_printf (out,
+ "GQuark\n%s_quark (void)\n"
+ "{\n"
+ "\tstatic GQuark q = 0;\n"
+ "\tif (q == 0)\n"
+ "\t\tq = g_quark_from_static_string (\"%s\");\n"
+ "\treturn q;\n"
+ "}\n\n",
+ funcprefix, str);
+
+ g_free (str);
+
+ g_free (funcprefix);
+ g_free (type);
+}
+
static void
generate_outfiles(void)
{
print_includes();
- for(li=nodes;li;li=g_list_next(li)) {
+ for (li = nodes; li != NULL; li = li->next) {
Node *node = li->data;
- if(node->type == CCODE_NODE) {
+ if (node->type == CCODE_NODE) {
CCode *cc = (CCode *)node;
- if(cc->cctype != HT_CCODE &&
- cc->cctype != AT_CCODE)
- print_ccode_block((CCode *)node);
- } else if(node->type == CLASS_NODE) {
- print_class_block((Class *)node);
- } else
+ if (cc->cctype != HT_CCODE &&
+ cc->cctype != AT_CCODE)
+ print_ccode_block ((CCode *)node);
+ } else if (node->type == CLASS_NODE) {
+ print_class_block ((Class *)node);
+ } else if (node->type == ENUMDEF_NODE) {
+ print_enum ((EnumDef *)node);
+ } else if (node->type == FLAGS_NODE) {
+ print_flags ((Flags *)node);
+ } else if (node->type == ERROR_NODE) {
+ print_error ((Error *)node);
+ } else {
g_assert_not_reached();
+ }
}
print_header_postfixes();
"\t--always-private-struct Always create a private pointer "
"in\n"
"\t the object structure\n"
+ "\t--m4 Preprocess source with m4. "
+ "Following args will\n"
+ "\t be passed to m4\n"
+ "\t--m4-dir Print directory that will be "
+ "searched for m4\n"
+ "\t files\n"
"\t--no-write,-n Don't write output files, just "
"check syntax\n"
"\t--no-lines Don't print '#line' to output\n"
int i;
int got_file = FALSE;
int no_opts = FALSE;
+ int m4_opts = FALSE; /* if we are just passing on args to m4 */
filename = NULL;
for(i = 1 ; i < argc; i++) {
- if(no_opts ||
+ if(m4_opts) {
+ char *new_commandline;
+ g_assert(m4_commandline!=NULL);
+
+ /* check whether this one looks like the filename */
+ if((!strcmp(argv[i],"-") || argv[i][0] != '-')
+ && !got_file) {
+ const gchar *m4_flags=use_m4_clean?"":M4_FLAGS;
+ filename = argv[i];
+ got_file = TRUE;
+
+ /* insert flags before the filename */
+ new_commandline=g_strconcat(m4_commandline,
+ " ",
+ m4_flags,
+ " ",
+ argv[i],
+ NULL);
+ }
+
+ /* just an ordinary option */
+ else
+ new_commandline=g_strconcat(m4_commandline,
+ " ",
+ argv[i],
+ NULL);
+
+ /* free old commandline */
+ g_free(m4_commandline);
+ m4_commandline=new_commandline;
+
+ } else if(no_opts ||
argv[i][0] != '-') {
/*must be a file*/
if(got_file) {
/* no op */;
} else if(strcmp(argv[i], "--always-private-struct")==0) {
always_private_struct = TRUE;
+ } else if(strcmp(argv[i], "--m4-dir")==0) {
+ printf("%s\n",M4_INCLUDE_DIR);
+ exit(0);
+ } else if(strcmp(argv[i], "--m4")==0) {
+ use_m4 = TRUE;
+ use_m4_clean=FALSE;
+ m4_opts = TRUE;
+ m4_commandline=g_strdup(M4_COMMANDLINE);
+ } else if(strcmp(argv[i], "--m4-clean")==0) {
+ use_m4 = TRUE;
+ use_m4_clean=TRUE;
+ m4_opts = TRUE;
+ m4_commandline=g_strdup(M4_COMMANDLINE);
} else if(strcmp(argv[i], "--")==0) {
/*further arguments are files*/
no_opts = TRUE;
}
}
}
+
+#if 0
+ /* if we are using m4, and got no filename, append m4 flags now */
+ if(!got_file && use_m4 && !use_m4_clean) {
+ char *new_commandline;
+ new_commandline=g_strconcat(m4_commandline,
+ " ",
+ M4_FLAGS,
+ NULL);
+ g_free(m4_commandline);
+ m4_commandline=new_commandline;
+ }
+#endif
}
/* this is a somewhat ugly hack, but it appears to work */
{
parse_options(argc, argv);
- if(filename) {
+ if(use_m4) {
+ yyin = popen(m4_commandline, "r");
+ if(!yyin) {
+ fprintf(stderr, "Error: can't open pipe from '%s'\n",
+ m4_commandline);
+ exit(1);
+ }
+ } else if(filename) {
yyin = fopen(filename, "r");
if(!yyin) {
fprintf(stderr, "Error: can't open file '%s'\n",
filename);
exit(1);
}
- } else
+ }
+
+ if(filename==NULL)
filename = "stdin";
/* This is where parsing is done */
if(yyparse() != 0)
g_error("Parsing errors, quitting");
+ /* close input file */
+ if(use_m4) pclose(yyin);
+ else fclose(yyin);
+ yyin=stdin;
+
if( ! class)
error_print(GOB_ERROR, 0, " no class defined");
make_bases ();
make_inits ((Class *)class);
if(unreftors > 0) {
- need_shutdown = TRUE;
- find_shutdown ((Class *)class);
+ need_dispose = TRUE;
+ find_dispose ((Class *)class);
}
if (destructors > 0 ||
privates > 0) {