/* 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
*
make_bases (void)
{
filebase = replace_sep (((Class *)class)->otype, '-');
- g_strdown (filebase);
+ gob_strdown (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");
get_func = g_strdup_printf
("g_value_get_%s", (char *)li->data);
- g_strdown (get_func);
+ gob_strdown (get_func);
out_printf (out, ",\n\t\t(%s) "
"%s (param_values + %d)",
get_cast (li->data, FALSE),
(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"
! is_none) {
GList *gl, *al;
const char *sep = "";
- out_printf(out, "\tif(");
+ 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"
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);
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) {
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);
set_func = g_strdup_printf ("g_value_set%s_%s",
do_static ? "_static" : "",
(char *)ali->data);
- g_strdown (set_func);
+ 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)
{
set_func = g_strdup_printf ("g_value_set%s_%s",
do_static ? "_static" : "",
(char *)m->gtktypes->data);
- g_strdown (set_func);
+ 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;
+ /* 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_get_%s",
+ getfunc = g_strdup_printf ("g_value_%s_%s",
+ do_dup ? "dup" : "get",
(char *)m->gtktypes->data);
- g_strdown (getfunc);
+ 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"
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);
+ 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) {
/* 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