/* GOB C Preprocessor
* Copyright (C) 1999,2000 the Free Software Foundation.
* Copyright (C) 2000 Eazel, Inc.
- * Copyright (C) 2001 George Lebl
+ * Copyright (C) 2001-2004 George Lebl
*
* Author: George Lebl
*
extern GHashTable *gtk_doc_hash;
char *filebase;
+char *fullfilebase;
static char *funcbase;
static char *pfuncbase;
static char *macrobase;
static char *typebase;
static char *ptypebase;
+char *output_dir = NULL;
+
static int signals = 0; /* number of signals */
static int set_properties = 0; /* number of named (set) properties */
static int get_properties = 0; /* number of named (get) properties */
make_bases (void)
{
filebase = replace_sep (((Class *)class)->otype, '-');
- g_strdown (filebase);
+ gob_strdown (filebase);
+
+ if (output_dir != NULL &&
+ output_dir[0] != '\0') {
+ fullfilebase = g_build_filename (output_dir, filebase, NULL);
+ } else {
+ fullfilebase = g_strdup (filebase);
+ }
funcbase = replace_sep (((Class *)class)->otype, '_');
- g_strdown (funcbase);
+ gob_strdown (funcbase);
pfuncbase = replace_sep (((Class *)class)->ptype, '_');
- g_strdown (pfuncbase);
+ gob_strdown (pfuncbase);
macrobase = replace_sep (((Class *)class)->otype, '_');
- g_strup (macrobase);
+ gob_strup (macrobase);
macrois = make_pre_macro (((Class *)class)->otype, "IS");
pmacrois = make_pre_macro (((Class *)class)->ptype, "IS");
}
static void
-add_bad_hack_to_avoid_unused_warnings(Class *c)
+add_bad_hack_to_avoid_unused_warnings(const Class *c)
{
GList *li;
}
static void
-put_variable(Variable *v, FILE *fp)
+put_variable(const Variable *v, FILE *fp)
{
out_printf(fp, "\t");
print_type(fp, v->vtype, FALSE);
}
static void
-put_priv_method_prot(Method *m)
+put_priv_method_prot(const Method *m)
{
if(m->method == SIGNAL_LAST_METHOD ||
m->method == SIGNAL_FIRST_METHOD ||
}
static void
-find_dispose(Class *cl)
+find_dispose(const Class *cl)
{
GList *li;
}
static void
-find_finalize(Class *cl)
+find_finalize(const Class *cl)
{
GList *li;
/* compare a list of strings */
static gboolean
-is_list_equal(GList *a, GList *b)
+is_list_equal(const GList *a, const GList *b)
{
for(;a && b; a=a->next, b=b->next) {
if(strcmp(a->data, b->data)!=0) {
}
static Method *
-find_same_type_signal(Method *m)
+find_same_type_signal(const Method *m)
{
GList *li;
for(li=eq_signal_methods;li;li=li->next) {
}
static void
-print_signal_marsal_args (Method *m)
+print_signal_marsal_args (const Method *m)
{
if (strcmp (m->gtktypes->next->data, "NONE") != 0) {
GList *li;
for (i = 0, li = m->gtktypes->next;
li != NULL;
i++, li = li->next) {
- char *get_func = g_strdup_printf
- ("g_value_get_%s", (char *)li->data);
- g_strdown (get_func);
+ char *get_func;
+
+ if (strcmp (li->data, "UNICHAR") == 0)
+ /* hack because glib is braindamaged */
+ get_func = g_strdup ("g_value_get_uint");
+ else
+ get_func = g_strdup_printf
+ ("g_value_get_%s", (char *)li->data);
+
+ gob_strdown (get_func);
out_printf (out, ",\n\t\t(%s) "
"%s (param_values + %d)",
get_cast (li->data, FALSE),
gboolean take_ownership =
(strcmp ((char *)m->gtktypes->data, "STRING") == 0 ||
strcmp ((char *)m->gtktypes->data, "BOXED") == 0);
- char *set_func = g_strdup_printf ("g_value_set_%s%s",
- (char *)m->gtktypes->data,
- take_ownership ?
+ char *set_func;
+
+
+ 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",
+ (char *)m->gtktypes->data,
+ take_ownership ?
"_take_ownership" : "");
- g_strdown (set_func);
+ gob_strdown (set_func);
out_printf (out, "\n\t%s (return_value, v_return);\n",
set_func);
if(m->method == SIGNAL_LAST_METHOD ||
m->method == SIGNAL_FIRST_METHOD) {
char *s = g_strdup(m->id);
- g_strup(s);
+ gob_strup(s);
out_printf(out, "\t%s_SIGNAL,\n", s);
g_free(s);
}
if (n->type == PROPERTY_NODE) {
Property *p = (Property *)n;
char *s = g_strdup (p->name);
- g_strup (s);
+ gob_strup (s);
out_printf (out, ",\n\tPROP_%s", s);
g_free(s);
} else if (n->type == ARGUMENT_NODE) {
Argument *a = (Argument *)n;
char *s = g_strdup(a->name);
- g_strup(s);
+ gob_strup (s);
out_printf(out, ",\n\tPROP_%s", s);
g_free(s);
}
add_get_type(void)
{
/*char *chunk_size = ((Class*)class)->chunk_size;*/
-
+
out_printf(out,
"GType\n"
"%s_get_type (void)\n"
"{\n"
"\tstatic GType type = 0;\n\n"
- "\tif (type == 0) {\n"
+ "\tif ___GOB_UNLIKELY(type == 0) {\n"
"\t\tstatic const GTypeInfo info = {\n"
"\t\t\tsizeof (%sClass),\n"
"\t\t\t(GBaseInitFunc) NULL,\n"
"%s_get_type (void)\n" /* 1 */
"{\n"
"\tstatic GType type = 0;\n\n"
- "\tif (type == 0) {\n"
+ "\tif ___GOB_UNLIKELY(type == 0) {\n"
"\t\tstatic const GTypeInfo info = {\n"
"\t\t\tsizeof (%sClass),\n" /* 2 */
"\t\t\t(GBaseInitFunc) NULL,\n"
g_hash_table_insert(done, s, s);
f = replace_sep(m->otype, '_');
- g_strdown(f);
+ gob_strdown(f);
out_printf(out, "\t%sClass *%s_class = (%sClass *)%s;\n",
s, f, s, oname);
is_none = (strcmp(m->gtktypes->next->data, "NONE")==0);
sig = g_strdup (m->id);
- g_strup (sig);
+ gob_strup (sig);
flags = make_run_signal_flags (m, last);
out_printf (out, "\tobject_signals[%s_SIGNAL] =\n"
"\t\tg_signal_new (\"%s\",\n"
if(strcmp(m->gtktypes->data, "NONE") != 0 ||
! is_none) {
GList *gl, *al;
- char *sep = "";
- out_printf(out, "\tif(");
+ const char *sep = "";
+ out_printf(out, "\tif ___GOB_UNLIKELY(");
if(strcmp(m->gtktypes->data, "NONE") != 0) {
out_printf(out, "%s sizeof(", sep);
print_type(out, m->mtype, FALSE);
if (m->method == OVERRIDE_METHOD) {
char *s;
s = replace_sep (m->otype, '_');
- g_strdown (s);
+ gob_strdown (s);
if (need_dispose &&
dispose_handler != NULL &&
g_string_append (flags, ")");
s = g_strdup(a->name);
- g_strup(s);
+ 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\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"
#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)
{
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"
}
s = g_strdup (p->name);
- g_strup (s);
+ gob_strup (s);
out_printf (out, "\tg_object_class_install_property (g_object_class,\n"
"\t\tPROP_%s,\n"
"\t\tparam_spec);\n", s);
static void
print_destructor (Variable *v)
{
- char *root;
+ const char *root;
if(v->destructor == NULL)
return;
if (cbuf == NULL)
return;
s = g_strdup(a->name);
- g_strup(s);
+ gob_strup (s);
out_printf(out, "\tcase PROP_%s:\n\t{", s);
the_type_lower = g_strdup (a->gtktype);
- g_strdown (the_type_lower);
+ 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;
return;
name_upper = g_strdup (p->name);
- g_strup (name_upper);
+ gob_strup (name_upper);
the_type_lower = g_strdup (p->gtktype);
- g_strdown (the_type_lower);
+ gob_strdown (the_type_lower);
out_printf (out, "\tcase PROP_%s:\n", name_upper);
"\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);
+ 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);
}
}
+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)
+get_arg_names_for_macro (Method *m)
{
- char *p;
+ const char *sep;
GList *li;
GString *gs = g_string_new(NULL);
- p = "";
+ sep = "";
for(li=m->args;li;li=g_list_next(li)) {
FuncArg *arg = li->data;
- g_string_sprintfa(gs, "%s___%s", p, arg->name);
- p = ",";
+ g_string_sprintfa (gs, "%s___%s", sep, arg->name);
+ sep = ",";
}
- p = gs->str;
- g_string_free(gs, FALSE);
- return p;
+ return g_string_free (gs, FALSE);
}
static void
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);
+ 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);
}
s = g_strdup (m->id);
- g_strup (s);
+ gob_strup (s);
out_printf(out, "\tg_signal_emitv (___param_values,\n"
"\t\tobject_signals[%s_SIGNAL],\n"
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 = g_strdup_printf ("g_value_get_%s",
- (char *)m->gtktypes->data);
- g_strdown (getfunc);
+ 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\treturn (%s) %s (&___return_val);\n",
+ 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(s);
out_addline_outfile(out);
s = replace_sep(m->otype, '_');
- g_strup(s);
+ gob_strup (s);
args = get_arg_names_for_macro(m);
if(is_void) {
out_printf(out, "#define PARENT_HANDLER(%s) \\\n"
char *outfile, *outfileh, *outfileph;
if ( ! for_cpp)
- outfile = g_strconcat (filebase, ".c", NULL);
+ outfile = g_strconcat (fullfilebase, ".c", NULL);
else
- outfile = g_strconcat (filebase, ".cc", NULL);
+ outfile = g_strconcat (fullfilebase, ".cc", NULL);
if (no_touch_headers)
- outfileh = g_strconcat ("#gob#", filebase, ".h#gob#", NULL);
+ outfileh = g_strconcat (fullfilebase, ".h#gob#", NULL);
else
- outfileh = g_strconcat (filebase, ".h", NULL);
+ outfileh = g_strconcat (fullfilebase, ".h", NULL);
if ((privates > 0 || protecteds > 0 ||
private_header == PRIVATE_HEADER_ALWAYS) &&
private_header != PRIVATE_HEADER_NEVER)
- outfileph = g_strconcat (filebase, "-private.h", NULL);
+ outfileph = g_strconcat (fullfilebase, "-private.h", NULL);
else
outfileph = NULL;
if (no_write) {
devnull = fopen ("/dev/null", "w");
if (devnull == NULL)
- g_error ("Cannot open null device");
+ error_print (GOB_ERROR, 0, "Cannot open null device");
out = devnull;
outh = devnull;
if (outfileph != NULL)
} else {
out = fopen (outfile, "w");
if (out == NULL) {
- g_error ("Cannot open outfile: %s", outfile);
+ error_printf (GOB_ERROR, 0,
+ "Cannot open outfile: %s", outfile);
}
outh = fopen (outfileh, "w");
- if (outh == NULL)
- g_error ("Cannot open outfile: %s", outfileh);
+ if (outh == NULL) {
+ error_printf (GOB_ERROR, 0,
+ "Cannot open outfile: %s", outfileh);
+ }
if (outfileph != NULL) {
outph = fopen (outfileph, "w");
- if (outph == NULL)
- g_error ("Cannot open outfile: %s", outfileh);
+ if (outph == NULL) {
+ error_printf (GOB_ERROR, 0,
+ "Cannot open outfile: %s",
+ outfileph);
+ }
}
}
}
}
aname = g_strdup (name);
- g_strup (aname);
+ gob_strup (aname);
if (atype != NULL)
cast = get_type (atype, TRUE);
}
aname = g_strdup (name);
- g_strup (aname);
+ gob_strup (aname);
if (atype != NULL)
cast = get_type (atype, TRUE);
" * Main object structure\n"
" */\n");
s = replace_sep (c->otype, '_');
- g_strup (s);
+ gob_strup (s);
out_printf (outh, "#ifndef __TYPEDEF_%s__\n"
"#define __TYPEDEF_%s__\n", s, s);
g_free (s);
" */\n");
if ( ! overrode_get_type) {
- out_printf (outh, "GType\t%s_get_type\t(void)", funcbase);
- if ( ! no_gnu) {
- out_printf (outh, " G_GNUC_CONST;\n");
- } else {
- out_printf (outh, ";\n");
- }
+ out_printf (outh, "GType\t%s_get_type\t(void);\n", funcbase);
}
for(li = c->nodes; li != NULL; li = li->next) {
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)
{
char *p;
p = replace_sep(((Class *)class)->otype, '_');
- g_strup(p);
+ gob_strup (p);
out_printf(outh, "#ifndef __%s_H__\n#define __%s_H__\n\n", p, p);
if(outph)
out_printf(outph, "#ifndef __%s_PRIVATE_H__\n"
char *str;
funcprefix = replace_sep (enode->etype, '_');
- g_strdown (funcprefix);
+ gob_strdown (funcprefix);
out_printf (out, "static const GEnumValue _%s_values[] = {\n",
funcprefix);
type = remove_sep (enode->etype);
for (li = enode->values; li != NULL; li = li->next) {
EnumValue *value = li->data;
char *p;
- char *sname = g_strdown (g_strdup (value->name));
+ char *sname = gob_strdown (g_strdup (value->name));
while ((p = strchr (sname, '_')) != NULL)
*p = '-';
"GType\n%s_get_type (void)\n"
"{\n"
"\tstatic GType type = 0;\n"
- "\tif (type == 0)\n"
+ "\tif ___GOB_UNLIKELY(type == 0)\n"
"\t\ttype = g_enum_register_static (\"%s\", _%s_values);\n"
"\treturn type;\n"
"}\n\n",
int i;
funcprefix = replace_sep (fnode->ftype, '_');
- g_strdown (funcprefix);
+ gob_strdown (funcprefix);
out_printf (out, "static const GFlagsValue _%s_values[] = {\n",
funcprefix);
type = remove_sep (fnode->ftype);
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));
+ char *sname = gob_strdown (g_strdup (name));
while ((p = strchr (sname, '_')) != NULL)
*p = '-';
"GType\n%s_get_type (void)\n"
"{\n"
"\tstatic GType type = 0;\n"
- "\tif (type == 0)\n"
+ "\tif ___GOB_UNLIKELY(type == 0)\n"
"\t\ttype = g_flags_register_static (\"%s\", _%s_values);\n"
"\treturn type;\n"
"}\n\n",
char *str;
funcprefix = replace_sep (enode->etype, '_');
- g_strdown (funcprefix);
+ gob_strdown (funcprefix);
out_printf (out, "static const GEnumValue _%s_values[] = {\n",
funcprefix);
type = remove_sep (enode->etype);
for (li = enode->values; li != NULL; li = li->next) {
const char *name = li->data;
char *p;
- char *sname = g_strdown (g_strdup (name));
+ char *sname = gob_strdown (g_strdup (name));
while ((p = strchr (sname, '_')) != NULL)
*p = '-';
"GType\n%s_get_type (void)\n"
"{\n"
"\tstatic GType type = 0;\n"
- "\tif (type == 0)\n"
+ "\tif ___GOB_UNLIKELY(type == 0)\n"
"\t\ttype = g_enum_register_static (\"%s\", _%s_values);\n"
"\treturn type;\n"
"}\n\n",
out_printf (outh, "GQuark %s_quark (void);\n\n", funcprefix);
str = replace_sep (enode->etype, '-');
- g_strdown (str);
+ gob_strdown (str);
out_printf (out,
"GQuark\n%s_quark (void)\n"
print_includes();
+ print_more_useful_macros ();
+
for (li = nodes; li != NULL; li = li->next) {
Node *node = li->data;
if (node->type == CCODE_NODE) {
"really changed\n"
"\t--always-private-header Always create a private header "
"file,\n"
- "\t even if it would be empty "
- "[default]\n"
+ "\t even if it would be empty\n"
"\t--ondemand-private-header Create private header only when "
"needed\n"
+ "\t [default]\n"
"\t--no-private-header Don't create a private header, "
"put private\n"
"\t structure and protected "
"\t--no-lines Don't print '#line' to output\n"
"\t--no-self-alias Don't create self type and macro "
"aliases\n"
- "\t--no-kill-underscores Ignored for compatibility\n");
+ "\t--no-kill-underscores Ignored for compatibility\n"
+ "\t-o,--output-dir The directory where output "
+ "should be placed\n");
}
static void
use_m4_clean=TRUE;
m4_opts = TRUE;
m4_commandline=g_strdup(M4_COMMANDLINE);
+ } else if (strcmp (argv[i], "-o") == 0 ||
+ strcmp (argv[i], "--output-dir") == 0) {
+ if (i+1 < argc) {
+ output_dir = g_strdup (argv[i+1]);
+ i++;
+ } else {
+ output_dir = NULL;
+ }
+ } else if (strncmp (argv[i], "-o=", strlen ("-o=")) == 0 ||
+ strncmp (argv[i],
+ "--output-dir=",
+ strlen ("--output-dir=")) == 0) {
+ char *p = strchr (argv[i], '=');
+ g_assert (p != NULL);
+ output_dir = g_strdup (p+1);
} else if(strcmp(argv[i], "--")==0) {
/*further arguments are files*/
no_opts = TRUE;
static void
compare_and_move_header(void)
{
- char *hfnew = g_strconcat("#gob#", filebase, ".h#gob#", NULL);
- char *hf = g_strconcat(filebase, ".h", NULL);
+ char *hfnew = g_strconcat(fullfilebase, ".h#gob#", NULL);
+ char *hf = g_strconcat(fullfilebase, ".h", NULL);
struct stat s;
if(stat(hf, &s) == 0) {
char *s;
/* This is where parsing is done */
/*yydebug = 1;*/
if(yyparse() != 0)
- g_error("Parsing errors, quitting");
+ error_print (GOB_ERROR, 0, "Parsing errors, quitting");
/* close input file */
if(use_m4) pclose(yyin);
yyin=stdin;
if( ! class)
- error_print(GOB_ERROR, 0, " no class defined");
+ error_print (GOB_ERROR, 0, "no class defined");
exit_on_error = FALSE;
check_property_types ((Class *)class);
check_argument_types ((Class *)class);
check_func_arg_checks ((Class *)class);
+ check_for_class_destructors ((Class *)class);
exit_on_error = TRUE;
projects / gob-dx.git / blobdiff