gboolean no_lines = FALSE;
gboolean no_self_alias = FALSE;
gboolean no_kill_underscores = FALSE;
+gboolean always_private_struct = FALSE;
int method_unique_id = 1;
if(*p == '[') extra++;
}
g_string_append_c(gs, ' ');
-
- for(i=0; i<(t->stars+extra); i++)
- g_string_append_c(gs, '*');
+ if(t->pointer) {
+ 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;
else
tn = g_strdup(typename);
- type = new_type(1, tn, NULL);
+ type = new_type(tn, g_strdup("*"), NULL);
node = new_funcarg((Type *)type, name, NULL);
return g_list_prepend(NULL, node);
}
}
if(!got_class_init) {
node = new_method(NO_SCOPE, CLASS_INIT_METHOD,
- (Type *)new_type(0, g_strdup("void"), NULL),
+ (Type *)new_type(g_strdup("void"),
+ NULL, NULL),
NULL, NULL, NULL, g_strdup("class_init"),
make_func_arg(cl->otype, TRUE, g_strdup("c")),
NULL, NULL, NULL, 0, 0, FALSE,
}
if(!got_init) {
node = new_method(NO_SCOPE, INIT_METHOD,
- (Type *)new_type(0, g_strdup("void"), NULL),
+ (Type *)new_type(g_strdup("void"),
+ NULL, NULL),
NULL, NULL, NULL, g_strdup("init"),
make_func_arg(cl->otype, FALSE, g_strdup("o")),
NULL, NULL, NULL, 0, 0, FALSE,
find_destroy(Class *cl)
{
GList *li;
- Node *node;
destroy_handler = NULL;
for(li=cl->nodes;li;li=g_list_next(li)) {
find_finalize(Class *cl)
{
GList *li;
- Node *node;
finalize_handler = NULL;
for(li=cl->nodes;li;li=g_list_next(li)) {
static void
add_get_type(void)
{
+ char *chunk_size = ((Class*)class)->chunk_size;
+
out_printf(out, "guint\n"
"%s_get_type (void)\n"
"{\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\t(GtkClassInitFunc) NULL\n"
"\t\t};\n\n"
- "\t\ttype = gtk_type_unique (%s_get_type(), &info);\n"
- "\t}\n\n"
- "\treturn type;\n"
- "}\n\n",
+ "\t\ttype = gtk_type_unique (%s_get_type(), &info);\n",
funcbase, typebase, typebase, typebase,
funcbase, funcbase, pfuncbase);
+ if(chunk_size) {
+ out_printf(out, "#if %s > 0\n"
+ "\t\tgtk_type_set_chunk_alloc(type,%s);\n"
+ "#endif\n",
+ chunk_size, chunk_size);
+ }
+ out_printf(out,"\t}\n\n"
+ "\treturn type;\n"
+ "}\n\n");
}
static void
-add_overrides(Class *c, char *oname, gboolean did_gtk_obj)
+add_overrides(Class *c, char *oname, gboolean did_base_obj)
{
GList *li;
GHashTable *done;
char *s;
done = g_hash_table_new(g_str_hash, g_str_equal);
- if(did_gtk_obj) {
+ if(did_base_obj) {
s = g_strdup("GtkObject"); /* This was already done */
g_hash_table_insert(done, s, s);
+ s = g_strdup("GObject"); /* This was probably already done as well (if using Gtk/Glib 1.3/2.0) */
+ g_hash_table_insert(done, s, s);
}
for(li=c->nodes; li; li=g_list_next(li)) {
Node *n = li->data;
out_printf(out, "\tobject_signals[%s_SIGNAL] =\n"
"\t\tgtk_signal_new (\"%s\",\n"
"\t\t\t(GtkSignalRunType)(%s),\n"
- "\t\t\tgtk_object_class->type,\n"
+ "\t\t\tGTK_CLASS_TYPE(gtk_object_class),\n"
"\t\t\tGTK_SIGNAL_OFFSET (%sClass, %s),\n"
"\t\t\t%s,\n"
"\t\t\tGTK_TYPE_%s, %d",
for(li = c->nodes; li; li = g_list_next(li)) {
Node *n = li->data;
Method *m = (Method *)n;
- char *id;
if(n->type != METHOD_NODE ||
(m->method != SIGNAL_FIRST_METHOD &&
else if(need_finalize &&
finalize_handler &&
strcmp(m->id, "finalize") == 0)
- out_printf(out, "\tgtk_object_class->finalize "
- "= ___finalize;\n");
+ out_printf(out,
+ "#ifdef G_OBJECT_CLASS\n"
+ "\tg_object_class->finalize = ___finalize;\n"
+ "#else /* !G_OBJECT_CLASS */\n"
+ "\tgtk_object_class->finalize = ___finalize;\n"
+ "#endif /* G_OBJECT_CLASS */\n");
else if(m->cbuf)
out_printf(out,
"\t%s_class->%s = ___%x_%s_%s;\n",
out_printf(out, "\nstatic void\n"
"___destroy(GtkObject *obj_self)\n"
"{\n");
+ out_printf(out,
+ "#define __GOB_FUNCTION__ \"%s::destroy\"\n",
+ c->otype);
if(destructors > 0) {
out_printf(out, "\t%s *self G_GNUC_UNUSED = %s (obj_self);\n",
(guint)destroy_handler->unique_id, funcbase);
if(destroy_handler->line_no > 0)
out_addline_outfile(out);
+ } else {
+ out_printf(out,
+ "\tif(GTK_OBJECT_CLASS(parent_class)->destroy) \\\n"
+ "\t\t(* GTK_OBJECT_CLASS(parent_class)->destroy)(obj_self);\n");
}
if(destructors > 0) {
}
}
- out_printf(out, "}\n\n");
+ out_printf(out, "}\n"
+ "#undef __GOB_FUNCTION__\n\n");
}
static void
add_finalize(Class *c)
{
- out_printf(out, "\nstatic void\n"
+ /* Sort of a hack to make it work with gtk+ 1.3/2.0 */
+ out_printf(out,
+ "\n#ifdef G_OBJECT_CLASS\n"
+ "static void\n"
+ "___finalize(GObject *obj_self)\n"
+ "#else /* !G_OBJECT_CLASS */\n"
+ "static void\n"
"___finalize(GtkObject *obj_self)\n"
+ "#endif /* G_OBJECT_CLASS */\n"
"{\n");
+ out_printf(out,
+ "#define __GOB_FUNCTION__ \"%s::finalize\"\n",
+ c->otype);
if(privates > 0) {
out_printf(out, "\t%s *self = %s (obj_self);\n",
(guint)finalize_handler->unique_id, funcbase);
if(finalize_handler->line_no > 0)
out_addline_outfile(out);
+ } else {
+ /* Sort of a hack to make it work with gtk+ 1.3/2.0 */
+ out_printf(out,
+ "#ifdef G_OBJECT_CLASS\n"
+ "\tif(G_OBJECT_CLASS(parent_class)->finalize) \\\n"
+ "\t\t(* G_OBJECT_CLASS(parent_class)->finalize)(obj_self);\n"
+ "#else /* !G_OBJECT_CLASS */\n"
+ "\tif(GTK_OBJECT_CLASS(parent_class)->finalize) \\\n"
+ "\t\t(* GTK_OBJECT_CLASS(parent_class)->finalize)(obj_self);\n"
+ "#endif /* G_OBJECT_CLASS */\n");
}
if(privates > 0) {
"\tself->_priv = NULL;\n");
}
- out_printf(out, "}\n\n");
+ out_printf(out, "}\n"
+ "#undef __GOB_FUNCTION__\n\n");
}
static void
m, FALSE, FALSE, TRUE);
if(m->line_no > 0)
out_addline_outfile(out);
- out_printf(out, "{\n");
+ out_printf(out, "{\n"
+ "#define __GOB_FUNCTION__ \"%s::init\"\n",
+ c->otype);
if(privates > 0) {
out_printf(out, "\t%s->_priv = "
"g_new0 (%sPrivate, 1);\n",
((FuncArg *)m->args->data)->name,
typebase);
+ } else if(always_private_struct) {
+ out_printf(out, "\t%s->_priv = NULL;\n",
+ ((FuncArg *)m->args->data)->name);
}
if(initializers > 0) {
GList *li;
}
}
} else if(m->method == CLASS_INIT_METHOD) {
- gboolean did_gtk_obj = FALSE;
+ gboolean did_base_obj = FALSE;
if(m->line_no > 0)
out_addline_infile(out, m->line_no);
m, FALSE, FALSE, TRUE);
if(m->line_no > 0)
out_addline_outfile(out);
- out_printf(out, "{\n");
+ out_printf(out, "{\n"
+ "#define __GOB_FUNCTION__ \"%s::class_init\"\n",
+ c->otype);
if(signals > 0 ||
arguments > 0 ||
need_destroy ||
need_finalize) {
out_printf(out,
"\tGtkObjectClass *"
- "gtk_object_class = "
+ "gtk_object_class G_GNUC_UNUSED = "
"(GtkObjectClass*) %s;\n",
((FuncArg *)m->args->data)->name);
- did_gtk_obj = TRUE;
+ out_printf(out,
+ "#ifdef G_OBJECT_CLASS\n"
+ "\tGObjectClass *"
+ "g_object_class G_GNUC_UNUSED = "
+ "(GObjectClass*) %s;\n"
+ "#endif /* G_OBJECT_CLASS */\n",
+ ((FuncArg *)m->args->data)->name);
+ did_base_obj = TRUE;
}
if(overrides > 0)
add_overrides(c,
((FuncArg *)m->args->data)->name,
- did_gtk_obj);
+ did_base_obj);
if(initializers > 0) {
GList *li;
out_printf(out, "\tgtk_object_class->destroy "
"= ___destroy;\n");
if(need_finalize && !finalize_handler)
- out_printf(out, "\tgtk_object_class->finalize "
- "= ___finalize;\n");
+ out_printf(out,
+ "#ifdef G_OBJECT_CLASS\n"
+ "\tg_object_class->finalize = ___finalize;\n"
+ "#else /* !G_OBJECT_CLASS */\n"
+ "\tgtk_object_class->finalize = ___finalize;\n"
+ "#endif /* G_OBJECT_CLASS */\n");
if(arguments > 0)
make_arguments(c);
} else {
out_printf(out, "return;\n");
}
- out_printf(out, "}\n");
+ out_printf(out, "}\n"
+ "#undef __GOB_FUNCTION__\n");
}
}
"___object_%s_arg (GtkObject *object,\n"
"\tGtkArg *arg,\n"
"\tguint arg_id)\n"
+ "#define __GOB_FUNCTION__ \"%s::%s_arg\"\n"
"{\n"
"\t%s *self;\n\n"
"\tself = %s (object);\n\n"
"\tswitch (arg_id) {\n",
- is_set?"set":"get", typebase, macrobase);
+ is_set ? "set" : "get",
+ c->otype, is_set ? "set" : "get",
+ typebase, macrobase);
for(li=c->nodes;li;li=g_list_next(li)) {
Node *n = li->data;
out_printf(out, "\t\t}\n\t\tbreak;\n"
"#undef ARG\n");
}
- out_printf(out, "\tdefault:\n\t\tbreak;\n\t}\n}\n");
+ out_printf(out, "\tdefault:\n\t\tbreak;\n\t}\n}\n"
+ "#undef __GOB_FUNCTION__\n");
}
static void
gboolean is_void;
gboolean checked_null = FALSE;
is_void = (strcmp(m->mtype->name, "void")==0 &&
- m->mtype->stars == 0);
+ m->mtype->pointer == NULL);
- for(li=fa->checks;li;li=g_list_next(li)) {
+ for(li = fa->checks; li; li = g_list_next(li)) {
Check *ch = li->data;
char *s;
/* point to the method prot in .gob for failed checks */
static void
print_method_body(Method *m, int pre)
{
- out_printf(out, "{\n");
+ out_printf(out, "{\n"
+ "#define __GOB_FUNCTION__ \"%s::%s\"\n",
+ ((Class *)class)->otype,
+ get_real_id(m->id));
if(pre)
print_preconditions(m);
out_printf(out, "\t%s}", m->cbuf);
}
+ /* Note, there is no \n between the last } and this } so that
+ * errors/warnings reported on the end of the body get pointed to the
+ * right line in the .gob source */
out_printf(out, "}\n");
if(m->cbuf)
out_addline_outfile(out);
+ out_printf(out, "#undef __GOB_FUNCTION__\n");
}
static void
char *s, *args, *doc;
gboolean is_void;
is_void = (strcmp(m->mtype->name, "void")==0 &&
- m->mtype->stars == 0);
+ m->mtype->pointer == NULL);
out_printf(out, "\n");
if(m->method != OVERRIDE_METHOD) {
doc = get_gtk_doc(m->id);
out_printf(out, "{\n");
s = g_strdup(get_real_id(m->id));
g_strup(s);
- if(strcmp(m->mtype->name, "void")==0 &&
- m->mtype->stars==0) {
+ if(strcmp(m->mtype->name, "void") == 0 &&
+ m->mtype->pointer == NULL) {
print_preconditions(m);
if(((FuncArg *)m->args->data)->name)
out_printf(out, "\tgtk_signal_emit (GTK_OBJECT (%s),\n"
out_printf(out, "{\n"
"\t%sClass *klass;\n", typebase);
print_preconditions(m);
- out_printf(out, "\tklass = %s_CLASS(GTK_OBJECT(%s)->klass);\n\n"
+ out_printf(out, "\tklass = %s_GET_CLASS(%s);\n\n"
"\tif(klass->%s)\n",
macrobase, ((FuncArg *)m->args->data)->name,
get_real_id(m->id));
- if(strcmp(m->mtype->name, "void")==0 &&
- m->mtype->stars==0) {
+ if(strcmp(m->mtype->name, "void") == 0 &&
+ m->mtype->pointer == NULL) {
GList *li;
out_printf(out, "\t\t(*klass->%s)(%s",
get_real_id(m->id),
if((privates > 0 || protecteds > 0 ||
private_header == PRIVATE_HEADER_ALWAYS) &&
- !private_header != PRIVATE_HEADER_NEVER)
+ private_header != PRIVATE_HEADER_NEVER)
outfileph = g_strconcat(filebase, "-private.h", NULL);
else
outfileph = NULL;
"(%s_get_type())\n",
macrotype, funcbase);
out_printf(outh, "#define %s(obj)\t"
- "GTK_CHECK_CAST((obj), %s_get_type(),%s)\n",
+ "GTK_CHECK_CAST((obj), %s_get_type(), %s)\n",
macrobase, funcbase, typebase);
+ out_printf(outh, "#define %s_CONST(obj)\t"
+ "GTK_CHECK_CAST((obj), %s_get_type(), %s const)\n",
+ macrobase, funcbase, typebase);
out_printf(outh, "#define %s_CLASS(klass)\t"
- "GTK_CHECK_CLASS_CAST((klass),%s_get_type(),%sClass)\n",
+ "GTK_CHECK_CLASS_CAST((klass), %s_get_type(), %sClass)\n",
macrobase, funcbase, typebase);
out_printf(outh, "#define %s(obj)\t"
- "GTK_CHECK_TYPE((obj),%s_get_type ())\n\n",
+ "GTK_CHECK_TYPE((obj), %s_get_type ())\n\n",
macrois, funcbase);
+ out_printf(outh, "#ifdef GTK_CHECK_GET_CLASS\n"
+ "#define %s_GET_CLASS(obj)\t"
+ "GTK_CHECK_GET_CLASS((obj), %s_get_type(), %sClass)\n",
+ macrobase, funcbase, typebase);
+ out_printf(outh, "#else /* !GTK_CHECK_GET_CLASS */\n"
+ "#define %s_GET_CLASS(obj)\t"
+ "((%sClass *)GTK_OBJECT(obj)->klass)\n"
+ "#endif /* GTK_CHECK_GET_CLASS */\n",
+ macrobase, typebase);
- if(!no_self_alias) {
+ if( ! no_self_alias) {
out_printf(out, "/* self casting macros */\n");
out_printf(out, "#define SELF(x) %s(x)\n", macrobase);
+ out_printf(out, "#define SELF_CONST(x) %s_CONST(x)\n", macrobase);
out_printf(out, "#define IS_SELF(x) %s(x)\n", macrois);
out_printf(out, "#define SELF_CLASS(x) %s_CLASS(x)\n\n",
macrobase);
+ out_printf(out, "#define SELF_GET_CLASS(x) %s_GET_CLASS(x)\n\n",
+ macrobase);
out_printf(out, "/* self typedefs */\n");
out_printf(out, "typedef %s Self;\n", typebase);
out_printf(out, "typedef %sClass SelfClass;\n\n", typebase);
}
- if(privates > 0) {
+ out_printf(out, "/* GTK_CLASS_TYPE for 1.2<->1.3/2.0 GTK+ compatibility */\n");
+ out_printf(out,
+ "#ifndef GTK_CLASS_TYPE\n"
+ "#define GTK_CLASS_TYPE(x) (GTK_OBJECT_CLASS(x)->type)\n"
+ "#endif /* GTK_CLASS_TYPE */\n\n");
+
+ if(privates > 0 || always_private_struct) {
out_printf(outh, "\n/* Private structure type */\n");
out_printf(outh, "typedef struct _%sPrivate %sPrivate;\n",
typebase, typebase);
+ if(privates == 0)
+ out_printf(outh, "/* There are no privates, this "
+ "structure is thus never defined */\n");
}
out_printf(outh, "\n/*\n"
"#endif\n", typebase, typebase);
out_printf(outh, "struct _%s {\n\t%s __parent__;\n",
typebase, ptypebase);
- for(l=c->nodes;l;l=g_list_next(l)) {
+ for(l=c->nodes; l; l=g_list_next(l)) {
static gboolean printed_public = FALSE;
Node *n = l->data;
Variable *v = (Variable *)n;
if(n->type == VARIABLE_NODE &&
v->scope == PUBLIC_SCOPE) {
- if(!printed_public) {
+ if( ! printed_public) {
out_printf(outh, "\t/*< public >*/\n");
printed_public = TRUE;
}
}
}
/* put protecteds always AFTER publics */
- for(l=c->nodes;l;l=g_list_next(l)) {
+ for(l=c->nodes; l; l=g_list_next(l)) {
Node *n = l->data;
Variable *v = (Variable *)n;
if(n->type == VARIABLE_NODE &&
v->scope == PROTECTED_SCOPE) {
- if(!printed_private) {
+ if( ! printed_private) {
out_printf(outh, "\t/*< private >*/\n");
printed_private = TRUE;
}
put_variable((Variable *)n, outh);
}
}
- if(privates>0) {
- if(!printed_private)
+ if(privates > 0 || always_private_struct) {
+ if( ! printed_private)
out_printf(outh, "\t/*< private >*/\n");
out_printf(outh, "\t%sPrivate *_priv;\n", typebase);
}
out_printf(outfp, "struct _%sPrivate {\n",
typebase);
- for(l=c->nodes;l;l=l->next) {
+ for(l=c->nodes; l; l=l->next) {
Node *n = l->data;
Variable *v = (Variable *)n;
if(n->type == VARIABLE_NODE &&
out_printf(outh,
"struct _%sClass {\n\t%sClass __parent__;\n",
typebase, ptypebase);
- for(l=c->nodes;l;l=g_list_next(l)) {
+ for(l = c->nodes; l != NULL; l = l->next) {
Node *n = l->data;
if(n->type == METHOD_NODE)
put_vs_method((Method *)n);
}
/* put class scope variables */
- for(l=c->nodes;l;l=g_list_next(l)) {
+ for(l = c->nodes; l != NULL; l = l->next) {
Node *n = l->data;
Variable *v = (Variable *)n;
if(n->type == VARIABLE_NODE &&
out_printf(outh, "};\n\n");
out_printf(out, "/* here are local prototypes */\n");
- if(arguments>0) {
+ if(arguments > 0) {
out_printf(out, "static void ___object_set_arg "
"(GtkObject *object, GtkArg *arg, "
"guint arg_id);\n"
" */\n");
out_printf(outh, "guint\t%s_get_type\t(void);\n", funcbase);
- for(l=c->nodes;l;l=g_list_next(l)) {
+ for(l = c->nodes; l != NULL; l = l->next) {
Node *n = l->data;
if(n->type == METHOD_NODE) {
put_pub_method((Method *)n);
/* argument wrapping macros */
- if(arguments>0 && !no_gnu) {
+ if(arguments > 0 && ! no_gnu) {
out_printf(outh, "\n/*\n"
" * Argument wrapping macros\n"
" */\n");
out_printf(outh, "#else /* __GNUC__ */\n");
put_argument_nongnu_wrappers(c);
out_printf(outh, "#endif /* __GNUC__ */\n\n");
- } else if(arguments>0 && no_gnu) {
+ } else if(arguments > 0 && no_gnu) {
out_printf(outh, "\n/*\n"
" * Argument wrapping macros\n"
" */\n");
put_argument_nongnu_wrappers(c);
}
- if(signals>0) {
- for(l=c->nodes;l;l=g_list_next(l)) {
+ if(signals > 0) {
+ for(l = c->nodes; l != NULL; l = l->next) {
Node *n = l->data;
if(n->type == METHOD_NODE)
add_signal_prots((Method *)n);
add_inits(c);
- if(arguments>0) {
+ if(arguments > 0) {
add_getset_arg(c, TRUE);
add_getset_arg(c, FALSE);
}
- for(l=c->nodes;l;l=g_list_next(l)) {
+ for(l = c->nodes; l != NULL; l = l->next) {
Node *n = l->data;
if(n->type == METHOD_NODE)
put_method((Method *)n);
print_help(void)
{
fprintf(stderr, "Gob version %s\n\n", VERSION);
+ fprintf(stderr, "gob [options] file.gob\n\n");
fprintf(stderr, "Options:\n"
"\t--help,-h,-? Display this help\n"
"\t--version Display version\n"
"put private\n"
"\t structure and protected "
"prototypes inside c file\n"
+ "\t--always-private-struct Always create a private pointer "
+ "in\n"
+ "\t the object structure\n"
"\t--no-write,-n Don't write output files, just "
"check syntax\n"
"\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 Don't remove the leading underscore "
- "from short id names");
+ "from\n"
+ "\t short id names\n");
}
static void
} else if(strcmp(argv[i], "--no-touch-headers")==0) {
no_touch_headers = TRUE;
} else if(strcmp(argv[i], "--ondemand-private-header")==0) {
- private_header == PRIVATE_HEADER_ONDEMAND;
+ private_header = PRIVATE_HEADER_ONDEMAND;
} else if(strcmp(argv[i], "--always-private-header")==0) {
- private_header == PRIVATE_HEADER_ALWAYS;
+ private_header = PRIVATE_HEADER_ALWAYS;
} else if(strcmp(argv[i], "--no-private-header")==0) {
- private_header == PRIVATE_HEADER_NEVER;
+ private_header = PRIVATE_HEADER_NEVER;
} else if(strcmp(argv[i], "--no-gnu")==0) {
no_gnu = TRUE;
} else if(strcmp(argv[i], "--no-extern-c")==0) {
no_self_alias = TRUE;
} else if(strcmp(argv[i], "--no-kill-underscores")==0) {
no_kill_underscores = TRUE;
+ } else if(strcmp(argv[i], "--always-private-struct")==0) {
+ always_private_struct = TRUE;
} else if(strcmp(argv[i], "--")==0) {
/*further arguments are files*/
no_opts = TRUE;
check_nonvoidempty((Class *)class);
check_signal_args((Class *)class);
check_argument_types((Class *)class);
+ check_func_arg_checks((Class *)class);
exit_on_error = TRUE;