X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/4f7cfa972623842e64e3a8468696f1f6f40fd202..c9914e54f16c3315d47040f4cca2d3788228c504:/src/main.c diff --git a/src/main.c b/src/main.c index cdbfa42..a614e31 100644 --- a/src/main.c +++ b/src/main.c @@ -1,5 +1,6 @@ /* GOB C Preprocessor - * Copyright (C) 1999 the Free Software Foundation. + * Copyright (C) 1999,2000 the Free Software Foundation. + * Copyright (C) 2000 Eazel, Inc. * * Author: George Lebl * @@ -74,6 +75,12 @@ static gboolean made_aliases = FALSE; /* if we made any shorthand aliases static gboolean special_array[SPECIAL_LAST] = {0}; static gboolean any_special = FALSE; +static gboolean need_destroy = FALSE; +static Method * destroy_handler = NULL; + +static gboolean need_finalize = FALSE; +static Method * finalize_handler = NULL; + FILE *out = NULL; FILE *outh = NULL; FILE *outph = NULL; @@ -89,6 +96,11 @@ gint private_header = PRIVATE_HEADER_ALWAYS; gboolean no_extern_c = FALSE; gboolean no_write = FALSE; gboolean no_lines = FALSE; +gboolean no_self_alias = FALSE; +gboolean no_kill_underscores = FALSE; +gboolean always_private_struct = FALSE; + +int method_unique_id = 1; static void make_bases(void) @@ -136,10 +148,14 @@ get_type(Type *t, gboolean postfix_to_stars) 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; @@ -156,13 +172,13 @@ get_gtk_doc(char *id) val = g_hash_table_lookup(gtk_doc_hash, id); if(val) return g_strdup_printf("/**\n * %s_%s:\n%s **/\n", - funcbase, id, val); - s = g_strconcat(funcbase, "_", id, NULL); + funcbase, get_real_id(id), val); + s = g_strconcat(funcbase, "_", get_real_id(id), NULL); val = g_hash_table_lookup(gtk_doc_hash, s); g_free(s); if(val) return g_strdup_printf("/**\n * %s_%s:\n%s **/\n", - funcbase, id, val); + funcbase, get_real_id(id), val); return NULL; } @@ -182,18 +198,26 @@ print_method(FILE *fp, char *typeprefix, char *nameprefix, char *subnameprefix, char *namepostfix, char *postfix, Method *m, gboolean one_arg_per_line, - gboolean no_funcbase) + gboolean no_funcbase, + gboolean kill_underscore) { GList *li; + char *id; out_printf(fp, "%s", typeprefix); print_type(fp, m->mtype, TRUE); + + if(kill_underscore) + id = get_real_id(m->id); + else + id = m->id; + if(no_funcbase) out_printf(fp, "%s%s%s%s(", - nameprefix, subnameprefix, m->id, namepostfix); + nameprefix, subnameprefix, id, namepostfix); else out_printf(fp, "%s%s_%s%s%s(", - nameprefix, funcbase, subnameprefix, m->id, + nameprefix, funcbase, subnameprefix, id, namepostfix); if(m->args) { @@ -262,10 +286,11 @@ make_method_gnu_aliases(Class *c) out_printf(out, "static const typeof(&%s_%s) %s " "__attribute__ ((__unused__)) " - "= %s_%s;\n", funcbase, m->id, m->id, - funcbase, m->id); + "= %s_%s;\n", funcbase, get_real_id(m->id), + m->id, funcbase, get_real_id(m->id)); out_printf(out, "#define %s(args...) " - "%s_%s(##args)\n", m->id, funcbase, m->id); + "%s_%s(##args)\n", m->id, + funcbase, get_real_id(m->id)); } } } @@ -290,8 +315,9 @@ make_method_nongnu_aliases(Class *c) continue; print_method(out, "static ", "(* ", "", ") ", "", - m, FALSE, TRUE); - out_printf(out, " = %s_%s;\n", funcbase, m->id); + m, FALSE, TRUE, FALSE); + out_printf(out, " = %s_%s;\n", funcbase, + get_real_id(m->id)); made_aliases = TRUE; } @@ -366,10 +392,11 @@ put_vs_method(Method *m) /* if a signal mark it as such */ if(m->method != VIRTUAL_METHOD) - print_method(outh, "\t/*signal*/", "(* ", "", ") ", ";\n", m, - FALSE, TRUE); + print_method(outh, "\t/*signal*/", "(* ", "", ") ", ";\n", + m, FALSE, TRUE, TRUE); else - print_method(outh, "\t", "(* ", "", ") ", ";\n", m, FALSE, TRUE); + print_method(outh, "\t", "(* ", "", ") ", ";\n", + m, FALSE, TRUE, TRUE); } static void @@ -378,7 +405,7 @@ put_pub_method(Method *m) if(m->scope != PUBLIC_SCOPE) return; - print_method(outh, "", "\t", "", "\t", ";\n", m, TRUE, FALSE); + print_method(outh, "", "\t", "", "\t", ";\n", m, TRUE, FALSE, TRUE); } /* I'm starting not to like this idea */ @@ -426,9 +453,11 @@ put_prot_method(Method *m) return; if(outph) - print_method(outph, "", "\t", "", "\t", ";\n", m, FALSE, FALSE); + print_method(outph, "", "\t", "", "\t", ";\n", + m, FALSE, FALSE, TRUE); else - print_method(out, "", "\t", "", "\t", ";\n", m, FALSE, FALSE); + print_method(out, "", "\t", "", "\t", ";\n", + m, FALSE, FALSE, TRUE); } static void @@ -440,17 +469,25 @@ put_priv_method_prot(Method *m) if(m->cbuf) print_method(out, "static ", "___real_", "", " ", ";\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); } + /* no else, here, it might still have a private prototype, it's not + * exclusive */ - if(m->scope == PRIVATE_SCOPE || + if((m->method == OVERRIDE_METHOD && + m->cbuf)) { + /* add unique ID */ + char *s = g_strdup_printf("___%x_", (guint)m->unique_id); + print_method(out, "static ", s, "", " ", + no_gnu?";\n":" G_GNUC_UNUSED;\n", + m, FALSE, FALSE, FALSE); + g_free(s); + } else if(m->scope == PRIVATE_SCOPE || m->method == INIT_METHOD || - m->method == CLASS_INIT_METHOD || - (m->method == OVERRIDE_METHOD && - m->cbuf)) + m->method == CLASS_INIT_METHOD) print_method(out, "static ", "", "", " ", no_gnu?";\n":" G_GNUC_UNUSED;\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); } static GList * @@ -465,7 +502,7 @@ make_func_arg(char *typename, int is_class, char *name) 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); } @@ -494,55 +531,89 @@ make_inits(Class *cl) } 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); + NULL, NULL, NULL, 0, 0, FALSE, + method_unique_id++); cl->nodes = g_list_prepend(cl->nodes, node); } 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); + NULL, NULL, NULL, 0, 0, FALSE, + method_unique_id++); cl->nodes = g_list_prepend(cl->nodes, node); } } static void -make_finalize(Class *cl) +find_destroy(Class *cl) { - int got_finalize = FALSE; GList *li; - Node *node; + + destroy_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, "finalize")==0) { - if(strcmp(m->otype, "Gtk:Object")==0) { - got_finalize = TRUE; - break; + strcmp(m->id, "destroy")==0) { + if(strcmp(m->otype, "Gtk:Object") != 0) { + print_error(FALSE, + "destroy method override " + "of class other then " + "Gtk:Object", + m->line_no); + } + if(g_list_length(m->args) != 1) { + print_error(FALSE, + "destroy method override " + "with more then one " + "parameter", + m->line_no); } - print_error(FALSE, "finalize method override " - "of class other then Gtk:Object", - m->line_no); + destroy_handler = m; + break; } } } - if(!got_finalize) { - node = new_method(NO_SCOPE, OVERRIDE_METHOD, - (Type *)new_type(0, g_strdup("void"), NULL), - g_strdup("Gtk:Object"), - NULL, NULL, g_strdup("finalize"), - make_func_arg("Gtk:Object", FALSE, g_strdup("o")), - NULL, NULL, - g_strdup("PARENT_HANDLER (o);\n"), - 0, 0, FALSE); - cl->nodes = g_list_append(cl->nodes, node); - overrides++; +} + +static void +find_finalize(Class *cl) +{ + GList *li; + + finalize_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, "finalize")==0) { + if(strcmp(m->otype, "Gtk:Object") != 0) { + print_error(FALSE, + "finalize method override " + "of class other then " + "Gtk:Object", + m->line_no); + } + if(g_list_length(m->args) != 1) { + print_error(FALSE, + "finalize method override " + "with more then one " + "parameter", + m->line_no); + } + finalize_handler = m; + break; + } + } } } @@ -686,7 +757,7 @@ add_enums(Class *c) Method *m = (Method *)n; if(m->method == SIGNAL_LAST_METHOD || m->method == SIGNAL_FIRST_METHOD) { - char *s = g_strdup(m->id); + char *s = g_strdup(get_real_id(m->id)); g_strup(s); out_printf(out, "\t%s_SIGNAL,\n", s); g_free(s); @@ -721,6 +792,8 @@ add_enums(Class *c) static void add_get_type(void) { + char *chunk_size = ((Class*)class)->chunk_size; + out_printf(out, "guint\n" "%s_get_type (void)\n" "{\n" @@ -734,27 +807,35 @@ add_get_type(void) "\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; @@ -763,7 +844,7 @@ add_overrides(Class *c, char *oname, gboolean did_gtk_obj) if(n->type != METHOD_NODE || m->method != OVERRIDE_METHOD) continue; - + s = remove_sep(m->otype); if(g_hash_table_lookup(done, s)) { @@ -776,7 +857,7 @@ add_overrides(Class *c, char *oname, gboolean did_gtk_obj) g_strdown(f); out_printf(out, "\t%sClass *%s_class = (%sClass *)%s;\n", - s, f, s, oname); + s, f, s, oname); g_free(f); } @@ -866,20 +947,21 @@ add_signals(Class *c) mar = g_strdup("gtk_signal_default_marshaller"); is_none = (strcmp(m->gtktypes->next->data, "NONE")==0); - - sig = g_strdup(m->id); + + sig = g_strdup(get_real_id(m->id)); g_strup(sig); flags = make_run_signal_flags(m, last); 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", - sig, m->id, + sig, get_real_id(m->id), flags, - typebase, m->id, mar, (char *)m->gtktypes->data, + typebase, get_real_id(m->id), mar, + (char *)m->gtktypes->data, is_none?0:g_list_length(m->gtktypes->next)); g_free(mar); g_free(sig); @@ -905,9 +987,10 @@ set_def_handlers(Class *c, char *oname) gboolean set_line = FALSE; out_printf(out, "\n"); - for(li=c->nodes;li;li=g_list_next(li)) { + for(li = c->nodes; li; li = g_list_next(li)) { Node *n = li->data; Method *m = (Method *)n; + if(n->type != METHOD_NODE || (m->method != SIGNAL_FIRST_METHOD && m->method != SIGNAL_LAST_METHOD && @@ -923,23 +1006,42 @@ set_def_handlers(Class *c, char *oname) set_line = FALSE; } + if(m->method == OVERRIDE_METHOD) { char *s; s = replace_sep(m->otype, '_'); g_strdown(s); - if(m->cbuf) - out_printf(out, "\t%s_class->%s = %s_%s;\n", - s, m->id, funcbase, m->id); + + if(need_destroy && + destroy_handler && + strcmp(m->id, "destroy") == 0) + out_printf(out, "\tgtk_object_class->destroy " + "= ___destroy;\n"); + else if(need_finalize && + finalize_handler && + strcmp(m->id, "finalize") == 0) + 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", + s, m->id, (guint)m->unique_id, + funcbase, m->id); else out_printf(out, "\t%s_class->%s = NULL;\n", s, m->id); } else { if(m->cbuf) out_printf(out, "\t%s->%s = ___real_%s_%s;\n", - oname, m->id, funcbase, m->id); + oname, get_real_id(m->id), + funcbase, get_real_id(m->id)); else out_printf(out, "\t%s->%s = NULL;\n", - oname, m->id); + oname, get_real_id(m->id)); } } if(set_line) @@ -1046,6 +1148,143 @@ print_initializer(Method *m, Variable *v) g_free(root); } +static void +print_destructor(Variable *v) +{ + char *root; + + if(v->destructor == NULL) + return; + + if(v->scope == PRIVATE_SCOPE) + root = "self->_priv"; + else + root = "self"; + + if(v->destructor_simple) { + if(v->destructor_line > 0) + out_addline_infile(out, v->destructor_line); + + out_printf(out, "\tif(%s->%s) { " + "((*(void (*)(void *))%s)) (%s->%s); " + "%s->%s = NULL; }\n", + root, v->id, v->destructor, root, v->id, + root, v->id); + + if(v->destructor_line > 0) + out_addline_outfile(out); + } else { + out_printf(out, "#define VAR (%s->%s)\n", root, v->id); + out_printf(out, "\t{\n"); + if(v->destructor_line > 0) + out_addline_infile(out, v->destructor_line); + + out_printf(out, "\t%s}\n", v->destructor); + + if(v->destructor_line > 0) + out_addline_outfile(out); + out_printf(out, "\tmemset(&VAR, 0, sizeof(VAR));\n"); + out_printf(out, "#undef VAR\n"); + } +} + +static void +add_destroy(Class *c) +{ + 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", + typebase, macrobase); + } + + if(destroy_handler) { + /* so we get possible bad argument warning */ + if(destroy_handler->line_no > 0) + out_addline_infile(out, destroy_handler->line_no); + out_printf(out, "\t___%x_%s_destroy(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) { + GList *li; + for(li = ((Class *)class)->nodes; + li != NULL; + li = li->next) { + Node *n = li->data; + Variable *v = (Variable *)n; + if(n->type == VARIABLE_NODE && + v->scope != CLASS_SCOPE) + print_destructor(v); + } + } + + out_printf(out, "}\n" + "#undef __GOB_FUNCTION__\n\n"); +} + +static void +add_finalize(Class *c) +{ + /* 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", + typebase, macrobase); + } + + if(finalize_handler) { + /* so we get possible bad argument warning */ + if(finalize_handler->line_no > 0) + out_addline_infile(out, finalize_handler->line_no); + out_printf(out, "\t___%x_%s_finalize(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) { + out_printf(out, "\tg_free (self->_priv);\n" + "\tself->_priv = NULL;\n"); + } + + out_printf(out, "}\n" + "#undef __GOB_FUNCTION__\n\n"); +} + static void add_inits(Class *c) { @@ -1060,15 +1299,20 @@ add_inits(Class *c) if(m->line_no > 0) out_addline_infile(out, m->line_no); print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + 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; @@ -1084,25 +1328,40 @@ add_inits(Class *c) } } } else if(m->method == CLASS_INIT_METHOD) { + gboolean did_base_obj = FALSE; + if(m->line_no > 0) out_addline_infile(out, m->line_no); print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); if(m->line_no > 0) out_addline_outfile(out); - out_printf(out, "{\n"); - if(signals>0 || - arguments>0) + 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); + 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) + if(overrides > 0) add_overrides(c, ((FuncArg *)m->args->data)->name, - (signals>0 || arguments>0)); + did_base_obj); if(initializers > 0) { GList *li; @@ -1124,12 +1383,25 @@ add_inits(Class *c) out_printf(out, "gtk_type_class (%s_get_type ());\n", pfuncbase); - if(signals>0) + if(signals > 0) add_signals(c); set_def_handlers(c, ((FuncArg *)m->args->data)->name); + + /* if there are no handlers for these things, we + * need to set them up here */ + if(need_destroy && !destroy_handler) + out_printf(out, "\tgtk_object_class->destroy " + "= ___destroy;\n"); + if(need_finalize && !finalize_handler) + 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) + if(arguments > 0) make_arguments(c); } else @@ -1144,7 +1416,8 @@ add_inits(Class *c) } else { out_printf(out, "return;\n"); } - out_printf(out, "}\n"); + out_printf(out, "}\n" + "#undef __GOB_FUNCTION__\n"); } } @@ -1156,11 +1429,14 @@ add_getset_arg(Class *c, gboolean is_set) "___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; @@ -1231,7 +1507,8 @@ add_getset_arg(Class *c, gboolean is_set) 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 @@ -1241,9 +1518,9 @@ print_checks(Method *m, FuncArg *fa) 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 */ @@ -1312,89 +1589,16 @@ print_preconditions(Method *m) out_addline_outfile(out); } -static void -print_destructor(char *self_id, Variable *v) -{ - char *root; - - if(v->destructor == NULL) - return; - - if(v->scope == PRIVATE_SCOPE) - root = g_strconcat(self_id, "->_priv", NULL); - else - root = g_strdup(self_id); - - if(v->destructor_simple) { - if(v->destructor_line > 0) - out_addline_infile(out, v->destructor_line); - - out_printf(out, "\tif(%s->%s) " - "((*(void (*)(void *))%s)) (%s->%s);\n", - root, v->id, v->destructor, root, v->id); - - if(v->destructor_line > 0) - out_addline_outfile(out); - } else { - out_printf(out, "#define VAR (%s->%s)\n", root, v->id); - out_printf(out, "\t{\n\t%s *self G_GNUC_UNUSED = %s;\n", - typebase, self_id); - if(v->destructor_line > 0) - out_addline_infile(out, v->destructor_line); - - out_printf(out, "\t%s}\n", v->destructor); - - if(v->destructor_line > 0) - out_addline_outfile(out); - out_printf(out, "#undef VAR\n"); - } - - g_free(root); -} - -/* put in code if it's needed */ -static void -put_in_gen_code(Method *m) -{ - if(m->method == OVERRIDE_METHOD && - strcmp(m->id, "finalize")==0) { - if(privates > 0 || destructors > 0) { - out_printf(out, "\t%s *___self = %s (%s);\n", - typebase, macrobase, - ((FuncArg *)m->args->data)->name); - } - if(destructors > 0) { - GList *li; - for(li = ((Class *)class)->nodes; - li != NULL; - li = li->next) { - Node *n = li->data; - Variable *v = (Variable *)n; - if(n->type == VARIABLE_NODE && - v->scope != CLASS_SCOPE) - print_destructor("___self", v); - } - } - if(privates > 0) { - out_printf(out, "\tg_free (___self->_priv);\n" - "\t___self->_priv = NULL;\n", - macrobase, - ((FuncArg *)m->args->data)->name, - macrobase, - ((FuncArg *)m->args->data)->name); - } - } -} - 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); - put_in_gen_code(m); - /* Note: the trailing }'s are on one line, this is so that we get the no return warning correctly and point to the correct line in the .gob file, yes this is slightly @@ -1407,10 +1611,14 @@ print_method_body(Method *m, int pre) 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 @@ -1455,40 +1663,44 @@ put_method(Method *m) 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"); - doc = get_gtk_doc(m->id); - if(doc) { - out_printf(out, "%s", doc); - g_free(doc); + if(m->method != OVERRIDE_METHOD) { + doc = get_gtk_doc(m->id); + if(doc) { + out_printf(out, "%s", doc); + g_free(doc); + } } switch(m->method) { case REGULAR_METHOD: - if(m->line_no>0) + if(m->line_no > 0) out_addline_infile(out, m->line_no); if(m->scope == PRIVATE_SCOPE) print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); else /* PUBLIC, PROTECTED */ print_method(out, "", "\n", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); print_method_body(m, TRUE); + /* the outfile line was added above */ break; case SIGNAL_FIRST_METHOD: case SIGNAL_LAST_METHOD: - if(m->line_no>0) + if(m->line_no > 0) out_addline_infile(out, m->line_no); if(m->scope == PRIVATE_SCOPE) print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); else /* PUBLIC, PROTECTED */ - print_method(out, "", "\n", "", " ", "\n", m, FALSE, FALSE); + print_method(out, "", "\n", "", " ", "\n", + m, FALSE, FALSE, TRUE); out_addline_outfile(out); out_printf(out, "{\n"); - s = g_strdup(m->id); + 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" @@ -1518,31 +1730,35 @@ put_method(Method *m) if(!m->cbuf) break; - if(m->line_no>0) + if(m->line_no > 0) out_addline_infile(out, m->line_no); print_method(out, "static ", "\n___real_", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); print_method_body(m, FALSE); + /* the outfile line was added above */ break; case VIRTUAL_METHOD: - if(m->line_no>0) + if(m->line_no > 0) out_addline_infile(out, m->line_no); if(m->scope==PRIVATE_SCOPE) print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); else /* PUBLIC, PROTECTED */ - print_method(out, "", "\n", "", " ", "\n", m, FALSE, FALSE); + print_method(out, "", "\n", "", " ", "\n", + m, FALSE, FALSE, TRUE); out_addline_outfile(out); 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, m->id); - if(strcmp(m->mtype->name, "void")==0 && - m->mtype->stars==0) { + macrobase, ((FuncArg *)m->args->data)->name, + get_real_id(m->id)); + if(strcmp(m->mtype->name, "void") == 0 && + m->mtype->pointer == NULL) { GList *li; - out_printf(out, "\t\t(*klass->%s)(%s", m->id, + out_printf(out, "\t\t(*klass->%s)(%s", + get_real_id(m->id), ((FuncArg *)m->args->data)->name); for(li=m->args->next;li;li=g_list_next(li)) { FuncArg *fa = li->data; @@ -1551,7 +1767,8 @@ put_method(Method *m) out_printf(out, ");\n}\n"); } else { GList *li; - out_printf(out, "\t\treturn (*klass->%s)(%s", m->id, + out_printf(out, "\t\treturn (*klass->%s)(%s", + get_real_id(m->id), ((FuncArg *)m->args->data)->name); for(li=m->args->next;li;li=g_list_next(li)) { FuncArg *fa = li->data; @@ -1571,19 +1788,23 @@ put_method(Method *m) if(!m->cbuf) break; - if(m->line_no>0) + if(m->line_no > 0) out_addline_infile(out, m->line_no); print_method(out, "static ", "\n___real_", "", " ", "\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); print_method_body(m, FALSE); + /* the outfile line was added above */ break; case OVERRIDE_METHOD: if(!m->cbuf) break; - if(m->line_no>0) + if(m->line_no > 0) out_addline_infile(out, m->line_no); - print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + s = g_strdup_printf("\n___%x_", (guint)m->unique_id); + print_method(out, "static ", s, "", " ", "\n", + m, FALSE, FALSE, FALSE); + g_free(s); + out_addline_outfile(out); s = replace_sep(m->otype, '_'); g_strup(s); args = get_arg_names_for_macro(m); @@ -1606,6 +1827,7 @@ put_method(Method *m) g_free(args); g_free(s); print_method_body(m, TRUE); + /* the outfile line was added above */ out_printf(out, "#undef PARENT_HANDLER\n"); break; default: @@ -1629,7 +1851,7 @@ open_files(void) 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; @@ -1836,24 +2058,55 @@ print_class_block(Class *c) "(%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) { + 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); + } + + 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"); - out_printf(out, "/* self casting macros */\n"); - out_printf(out, "#define SELF(x) %s(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); - - if(privates>0) { + 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" @@ -1868,13 +2121,13 @@ print_class_block(Class *c) "#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; } @@ -1882,26 +2135,26 @@ print_class_block(Class *c) } } /* 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(outh, "};\n"); - if(privates>0) { + if(privates > 0) { FILE *outfp; /* if we are to stick this into the private @@ -1914,7 +2167,7 @@ print_class_block(Class *c) 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 && @@ -1935,13 +2188,13 @@ print_class_block(Class *c) 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 && @@ -1951,7 +2204,7 @@ print_class_block(Class *c) 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" @@ -1965,7 +2218,7 @@ print_class_block(Class *c) " */\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); @@ -1993,7 +2246,7 @@ print_class_block(Class *c) /* argument wrapping macros */ - if(arguments>0 && !no_gnu) { + if(arguments > 0 && ! no_gnu) { out_printf(outh, "\n/*\n" " * Argument wrapping macros\n" " */\n"); @@ -2002,15 +2255,15 @@ print_class_block(Class *c) 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); @@ -2038,14 +2291,20 @@ print_class_block(Class *c) "#define GET_NEW ((%s *)gtk_type_new(%s_get_type()))\n\n", typebase, funcbase); + if(need_destroy) + add_destroy(c); + + if(need_finalize) + add_finalize(c); + 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); @@ -2086,6 +2345,10 @@ print_includes(void) gboolean found_header; char *p; + /* We may need string.h for memset */ + if(destructors > 0) + out_printf(out, "#include /* memset() */\n\n"); + p = g_strconcat(filebase, ".h", NULL); found_header = TRUE; if(!g_list_find_custom(include_files, p, (GCompareFunc)strcmp)) { @@ -2228,6 +2491,7 @@ static void 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" @@ -2249,9 +2513,17 @@ print_help(void) "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-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\n" + "\t short id names\n"); } static void @@ -2288,11 +2560,11 @@ parse_options(int argc, char *argv[]) } 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) { @@ -2301,6 +2573,12 @@ parse_options(int argc, char *argv[]) no_write = TRUE; } else if(strcmp(argv[i], "--no-lines")==0) { no_lines = TRUE; + } else if(strcmp(argv[i], "--no-self-alias")==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; @@ -2399,10 +2677,17 @@ main(int argc, char *argv[]) make_bases(); make_inits((Class *)class); - if(privates>0) - make_finalize((Class *)class); + if(destructors > 0) { + need_destroy = TRUE; + find_destroy((Class *)class); + } + if(privates > 0) { + need_finalize = TRUE; + find_finalize((Class *)class); + } check_bad_symbols((Class *)class); check_duplicate_symbols((Class *)class); + check_duplicate_overrides((Class *)class); check_duplicate_signals_args((Class *)class); check_public_new((Class *)class); check_vararg((Class *)class); @@ -2410,6 +2695,7 @@ main(int argc, char *argv[]) check_nonvoidempty((Class *)class); check_signal_args((Class *)class); check_argument_types((Class *)class); + check_func_arg_checks((Class *)class); exit_on_error = TRUE;