extern FILE * yyin;
extern Node *class;
extern GList *nodes;
+extern GList *enums;
extern GList *include_files;
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
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),(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), (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);
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;
+ char *name = replace_sep (interface, '_');
+ char *type = remove_sep (interface);
+
+ out_printf (out, "\nstatic void\n"
+ "___%s_init (%sIface *iface)\n"
+ "{\n",
+ name, type);
+
+ 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"
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
-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(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"
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",
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");