X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/5b42e9400440d86723a27747b2191ab8cd59c2ee..c9d96fcfcf9b74099775a3a260eccdfdc31474c7:/src/main.c diff --git a/src/main.c b/src/main.c index a84d0db..bf205ac 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 * @@ -28,7 +29,7 @@ #include #include -#include "tree.h" +#include "treefuncs.h" #include "parse.h" #include "out.h" #include "util.h" @@ -59,7 +60,8 @@ static char *typebase; static char *ptypebase; static int signals = 0; /* number of signals */ -static int arguments = 0; /* number of named arguments */ +static int set_arguments = 0; /* number of named (set) arguments */ +static int get_arguments = 0; /* number of named (get) arguments */ static int overrides = 0; /* number of override methods */ static int privates = 0; /* number of private data members */ static int protecteds = 0; /* number of protected methods */ @@ -74,6 +76,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; @@ -85,11 +93,15 @@ gboolean no_gnu = FALSE; gboolean exit_on_warn = FALSE; gboolean exit_on_error = TRUE; gboolean got_error = FALSE; -gboolean always_private_header = FALSE; -gboolean no_private_header = FALSE; +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) @@ -115,7 +127,7 @@ make_bases(void) } static char * -get_type(Type *t, gboolean postfix_to_stars) +get_type(const Type *t, gboolean postfix_to_stars) { char *s; int i; @@ -128,7 +140,7 @@ get_type(Type *t, gboolean postfix_to_stars) extra = 0; if(postfix_to_stars) { - char *p; + const char *p; /*XXX: this is ugly perhaps we can do this whole postfix thing in a nicer way, we just count the number of '[' s and from that we deduce the number of dimensions, so that we can print @@ -137,19 +149,23 @@ 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; } static char * -get_gtk_doc(char *id) +get_gtk_doc(const char *id) { - char *val, *s; + char *val; if(!gtk_doc_hash) return NULL; @@ -157,18 +173,16 @@ 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); - val = g_hash_table_lookup(gtk_doc_hash, s); - g_free(s); + funcbase, get_real_id(id), val); + val = g_hash_table_lookup(gtk_doc_hash, get_real_id(id)); if(val) return g_strdup_printf("/**\n * %s_%s:\n%s **/\n", - funcbase, id, val); + funcbase, get_real_id(id), val); return NULL; } static void -print_type(FILE *fp, Type *t, gboolean postfix_to_stars) +print_type(FILE *fp, const Type *t, gboolean postfix_to_stars) { char *s; @@ -179,22 +193,30 @@ print_type(FILE *fp, Type *t, gboolean postfix_to_stars) static void -print_method(FILE *fp, char *typeprefix, char *nameprefix, - char *subnameprefix, - char *namepostfix, char *postfix, Method *m, +print_method(FILE *fp, const char *typeprefix, const char *nameprefix, + const char *subnameprefix, + const char *namepostfix, const char *postfix, const Method *m, gboolean one_arg_per_line, - gboolean no_funcbase) + gboolean no_funcbase, + gboolean kill_underscore) { GList *li; + const 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) { @@ -203,17 +225,17 @@ print_method(FILE *fp, char *typeprefix, char *nameprefix, print_type(fp, arg->atype, FALSE); if(li->next) out_printf(fp, "%s%s,%s", arg->name, - arg->atype->postfix? - arg->atype->postfix:"", - one_arg_per_line?"\n\t\t\t\t\t":" "); + arg->atype->postfix ? + arg->atype->postfix : "", + one_arg_per_line ? "\n\t\t\t\t\t" : " "); else out_printf(fp, "%s%s", arg->name, - arg->atype->postfix? - arg->atype->postfix:""); + arg->atype->postfix ? + arg->atype->postfix : ""); } if(m->vararg) out_printf(fp, ",%s...", - one_arg_per_line?"\n\t\t\t\t\t":" "); + one_arg_per_line ? "\n\t\t\t\t\t" : " "); } else { out_printf(fp, "void"); } @@ -242,12 +264,13 @@ any_method_to_alias(Class *c) } +/* just the vararg macros, we use the same func pointers for these as in non-gnu */ static void make_method_gnu_aliases(Class *c) { GList *li; - for(li=c->nodes;li;li=g_list_next(li)) { + for(li = c->nodes; li != NULL; li = li->next) { Node *node = li->data; if(node->type == METHOD_NODE) { Method *m = (Method *)node; @@ -261,12 +284,14 @@ make_method_gnu_aliases(Class *c) if(for_cpp && strcmp(m->id, "new")==0) continue; - out_printf(out, "static const typeof(&%s_%s) %s " - "__attribute__ ((__unused__)) " - "= %s_%s;\n", funcbase, m->id, m->id, - funcbase, m->id); - out_printf(out, "#define %s(args...) " - "%s_%s(##args)\n", m->id, funcbase, m->id); + if(m->args != NULL) + out_printf(out, "#define %s(args...) " + "%s_%s(##args)\n", m->id, + funcbase, get_real_id(m->id)); + else + out_printf(out, "#define %s() " + "%s_%s()\n", m->id, + funcbase, get_real_id(m->id)); } } } @@ -275,6 +300,8 @@ static void make_method_nongnu_aliases(Class *c) { GList *li; + + gboolean local_made_aliases = FALSE; for(li=c->nodes; li; li=g_list_next(li)) { Node *node = li->data; @@ -290,13 +317,21 @@ make_method_nongnu_aliases(Class *c) if(for_cpp && strcmp(m->id, "new")==0) continue; - print_method(out, "static ", "(* ", "", ") ", "", - m, FALSE, TRUE); - out_printf(out, " = %s_%s;\n", funcbase, m->id); + if( ! local_made_aliases) + out_printf(out, "\n/* Short form pointers */\n"); + + print_method(out, "static ", "(* const ", "", ") ", "", + m, FALSE, TRUE, FALSE); + out_printf(out, " = %s_%s;\n", funcbase, + get_real_id(m->id)); - made_aliases = TRUE; + local_made_aliases = TRUE; } } + if(local_made_aliases) { + out_printf(out, "\n"); + made_aliases = TRUE; + } } static void @@ -305,11 +340,11 @@ add_bad_hack_to_avoid_unused_warnings(Class *c) GList *li; /* if we haven't had any methods, just return */ - if(!made_aliases) + if( ! made_aliases) return; - if(!no_gnu) - out_printf(out,"\n\n#ifndef __GNUC__\n"); + if( ! no_gnu) + out_printf(out, "\n\n#if (!defined __GNUC__) || (defined __GNUC__ && defined __STRICT_ANSI__)\n"); out_printf(out, "/*REALLY BAD HACK\n" " This is to avoid unused warnings if you don't call\n" @@ -318,7 +353,7 @@ add_bad_hack_to_avoid_unused_warnings(Class *c) " extentions to make saner, faster code */\n" "static void\n" "___%s_really_bad_hack_to_avoid_warnings(void)\n" - "{\n",funcbase); + "{\n", funcbase); for(li=c->nodes;li;li=g_list_next(li)) { Node *node = li->data; if(node->type == METHOD_NODE) { @@ -330,35 +365,35 @@ add_bad_hack_to_avoid_unused_warnings(Class *c) continue; /* in C++ mode we don't alias new */ - if(for_cpp && strcmp(m->id,"new")==0) + if(for_cpp && strcmp(m->id, "new")==0) continue; - out_printf(out,"\t((void (*)(void))%s)();\n",m->id); + out_printf(out, "\t((void (*)(void))%s)();\n", m->id); } } out_printf(out, "\t___%s_really_bad_hack_to_avoid_warnings();\n", funcbase); if(!no_gnu) - out_printf(out,"}\n#endif /* __GNUC__ */\n\n"); + out_printf(out, "}\n#endif /* !__GNUC__ || (__GNUC__ && __STRICT_ANSI__) */\n\n"); else - out_printf(out,"}\n\n"); + out_printf(out, "}\n\n"); } static void put_variable(Variable *v, FILE *fp) { - out_printf(fp,"\t"); - print_type(fp,v->vtype,FALSE); - out_printf(fp,"%s%s;",v->id, + out_printf(fp, "\t"); + print_type(fp, v->vtype, FALSE); + out_printf(fp, "%s%s;", v->id, v->vtype->postfix? v->vtype->postfix:""); if(v->scope == PROTECTED_SCOPE) - out_printf(fp," /* protected */"); - out_printf(fp,"\n"); + out_printf(fp, " /* protected */"); + out_printf(fp, "\n"); } static void -put_vs_method(Method *m) +put_vs_method(const Method *m) { if(m->method != SIGNAL_LAST_METHOD && m->method != SIGNAL_FIRST_METHOD && @@ -367,19 +402,20 @@ 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 -put_pub_method(Method *m) +put_pub_method(const 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 */ @@ -421,15 +457,17 @@ put_signal_connect(Method *m) static void -put_prot_method(Method *m) +put_prot_method(const Method *m) { if(m->scope != PROTECTED_SCOPE) 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 @@ -441,17 +479,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 || - m->method == INIT_METHOD || - m->method == CLASS_INIT_METHOD || - (m->method == OVERRIDE_METHOD && - m->cbuf)) + 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) print_method(out, "static ", "", "", " ", no_gnu?";\n":" G_GNUC_UNUSED;\n", - m, FALSE, FALSE); + m, FALSE, FALSE, TRUE); } static GList * @@ -462,12 +508,12 @@ make_func_arg(char *typename, int is_class, char *name) char *tn; if(is_class) - tn = g_strconcat(typename,":Class",NULL); + tn = g_strconcat(typename, ":Class", NULL); else tn = g_strdup(typename); - type = new_type(1,tn,NULL); - node = new_funcarg((Type *)type,name,NULL); + type = new_type(tn, g_strdup("*"), NULL); + node = new_funcarg((Type *)type, name, NULL); return g_list_prepend(NULL, node); } @@ -484,66 +530,98 @@ make_inits(Class *cl) Method *m = (Method *)n; if(m->method == INIT_METHOD) { if(got_init) - print_error(FALSE,"init defined more then once",m->line_no); + error_print(GOB_ERROR, m->line_no, "init defined more then once"); got_init = TRUE; } else if(m->method == CLASS_INIT_METHOD) { if(got_class_init) - print_error(FALSE,"class_init defined more then once",m->line_no); + error_print(GOB_ERROR, m->line_no, "class_init defined more then once"); got_class_init = TRUE; } } } 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, 0, 0, FALSE); - cl->nodes = g_list_prepend(cl->nodes,node); + 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, 0, 0, FALSE); - cl->nodes = g_list_prepend(cl->nodes,node); + 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) { + error_print(GOB_ERROR, m->line_no, + "destroy method override " + "of class other then " + "Gtk:Object"); + } + if(g_list_length(m->args) != 1) { + error_print(GOB_ERROR, m->line_no, + "destroy method override " + "with more then one " + "parameter"); } - 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, - 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 && + strcmp(m->otype, "G:Object") != 0) { + error_print(GOB_ERROR, m->line_no, + "finalize method override " + "of class other then " + "Gtk:Object (or G:Object" + "for GTK+ 2.0)"); + } + if(g_list_length(m->args) != 1) { + error_print(GOB_ERROR, m->line_no, + "finalize method override " + "with more then one " + "parameter"); + } + finalize_handler = m; + break; + } + } } } @@ -561,7 +639,7 @@ static gboolean is_list_equal(GList *a, GList *b) { for(;a && b; a=a->next, b=b->next) { - if(strcmp(a->data,b->data)!=0) { + if(strcmp(a->data, b->data)!=0) { return FALSE; } } @@ -577,7 +655,7 @@ find_same_type_signal(Method *m) GList *li; for(li=eq_signal_methods;li;li=li->next) { Method *mm = li->data; - if(is_list_equal(mm->gtktypes,m->gtktypes)) + if(is_list_equal(mm->gtktypes, m->gtktypes)) return mm; } return NULL; @@ -586,19 +664,19 @@ find_same_type_signal(Method *m) static void print_signal_marsal_args(Method *m) { - if(strcmp(m->gtktypes->next->data,"NONE")!=0) { + if(strcmp(m->gtktypes->next->data, "NONE")!=0) { GList *li; int i; - for(i=0,li=m->gtktypes->next;li; - i++,li=g_list_next(li)) { + for(i=0, li=m->gtktypes->next;li; + i++, li=g_list_next(li)) { if(!for_cpp) out_printf(out, ",\n\t\tGTK_VALUE_%s(args[%d])", - (char *)li->data,i); + (char *)li->data, i); else { out_printf(out, ",\n\t\t(%s)" "GTK_VALUE_%s(args[%d])", get_cast(li->data, FALSE), - (char *)li->data,i); + (char *)li->data, i); } } } @@ -619,53 +697,56 @@ add_signal_prots(Method *m) return; if(!marsh) - marsh = g_hash_table_new(NULL,NULL); + marsh = g_hash_table_new(NULL, NULL); - if(strcmp(m->gtktypes->data,"NONE")==0 && - strcmp(m->gtktypes->next->data,"NONE")==0) + if(strcmp(m->gtktypes->data, "NONE")==0 && + strcmp(m->gtktypes->next->data, "NONE")==0) return; /* if we already did a signal prototype just use that */ mm = find_same_type_signal(m); if(mm) { - s = g_hash_table_lookup(marsh,mm); - g_hash_table_insert(marsh,m,s); + s = g_hash_table_lookup(marsh, mm); + g_hash_table_insert(marsh, m, s); return; } - s = g_strdup_printf("Sig%d",sig++); + s = g_strdup_printf("Sig%d", sig++); - g_hash_table_insert(marsh,m,s); - eq_signal_methods = g_list_prepend(eq_signal_methods,m); + g_hash_table_insert(marsh, m, s); + eq_signal_methods = g_list_prepend(eq_signal_methods, m); /* we know that we'll know all the gtktypes (so get_cast can't fail) */ - out_printf(out,"\ntypedef %s (*___%s) (%s *, ", + out_printf(out, "\ntypedef %s (*___%s) (%s *, ", get_cast(m->gtktypes->data, FALSE), s, typebase); - for(li=m->gtktypes->next;li;li=g_list_next(li)) - out_printf(out, "%s, ", get_cast(li->data, FALSE)); - out_printf(out,"gpointer);\n"); + if(strcmp(m->gtktypes->next->data, "NONE")!=0) { + for(li=m->gtktypes->next; li; li=g_list_next(li)) + out_printf(out, "%s, ", get_cast(li->data, FALSE)); + } + out_printf(out, "gpointer);\n"); - out_printf(out,"\nstatic void\n" + out_printf(out, "\nstatic void\n" "___marshal_%s (GtkObject * object,\n" "\tGtkSignalFunc func,\n" "\tgpointer func_data,\n" "\tGtkArg * args)\n" - "{\n",s); + "{\n", s); - if(strcmp(m->gtktypes->data,"NONE")==0) { + if(strcmp(m->gtktypes->data, "NONE")==0) { out_printf(out, "\t___%s rfunc;\n\n" "\trfunc = (___%s)func;\n\n" - "\t(*rfunc)((%s *)object",s,s,typebase); + "\t(*rfunc)((%s *)object", s, s, typebase); } else { - out_printf(out, "\t___%s rfunc;\n\t",s); - print_type(out,m->mtype,TRUE); - out_printf(out, " *retval;\n\n" - "\trfunc = (___%s)func;\n\n" - "\tretval = GTK_RETLOC_%s(args[%d]);\n\n" - "\t*retval = (*rfunc)((%s *)object", - s,(char *)m->gtktypes->data, - g_list_length(m->gtktypes)-1,typebase); + const char *retcast = get_cast(m->gtktypes->data, FALSE); + out_printf(out, + "\t___%s rfunc;\n\t" + "%s *retval;\n\n" + "\trfunc = (___%s)func;\n\n" + "\tretval = GTK_RETLOC_%s(args[%d]);\n\n" + "\t*retval = (*rfunc)((%s *)object", + s, retcast, s, (char *)m->gtktypes->data, + g_list_length(m->gtktypes)-1, typebase); } print_signal_marsal_args(m); @@ -675,33 +756,33 @@ static void add_enums(Class *c) { GList *li; - out_printf(out,"\n"); + out_printf(out, "\n"); if(signals>0) { - out_printf(out,"enum {\n"); + out_printf(out, "enum {\n"); for(li=c->nodes;li;li=g_list_next(li)) { Node *n = li->data; if(n->type == METHOD_NODE) { 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); + out_printf(out, "\t%s_SIGNAL,\n", s); g_free(s); } } } - out_printf(out,"\tLAST_SIGNAL\n};\n\n"); + out_printf(out, "\tLAST_SIGNAL\n};\n\n"); } - if(arguments>0) { - out_printf(out,"enum {\n\tARG_0"); + if(set_arguments > 0 || get_arguments > 0) { + out_printf(out, "enum {\n\tARG_0"); for(li=c->nodes;li;li=g_list_next(li)) { Node *n = li->data; if(n->type == ARGUMENT_NODE) { Argument *a = (Argument *)n; char *s = g_strdup(a->name); g_strup(s); - out_printf(out,",\n\tARG_%s",s); + out_printf(out, ",\n\tARG_%s", s); g_free(s); } } @@ -713,46 +794,59 @@ add_enums(Class *c) "static guint object_signals[LAST_SIGNAL] = {0};\n\n"); out_printf(out, "/* pointer to the class of our parent */\n"); - out_printf(out, "static %sClass *parent_class = NULL;\n\n",ptypebase); + out_printf(out, "static %sClass *parent_class = NULL;\n\n", ptypebase); } static void add_get_type(void) { - out_printf(out, "guint\n" - "%s_get_type (void)\n" - "{\n" - "\tstatic guint type = 0;\n\n" - "\tif (!type) {\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 = gtk_type_unique (%s_get_type(), &info);\n" - "\t}\n\n" - "\treturn type;\n" - "}\n\n", - funcbase,typebase,typebase,typebase, - funcbase,funcbase,pfuncbase); + char *chunk_size = ((Class*)class)->chunk_size; + + out_printf(out, + "GtkType\n" + "%s_get_type (void)\n" + "{\n" + "\tstatic guint type = 0;\n\n" + "\tif ( ! type) {\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 = 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, const 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; @@ -761,24 +855,24 @@ 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)) { + if(g_hash_table_lookup(done, s)) { g_free(s); continue; } - g_hash_table_insert(done,s,s); + g_hash_table_insert(done, s, s); - f = replace_sep(m->otype,'_'); + f = replace_sep(m->otype, '_'); g_strdown(f); - out_printf(out,"\t%sClass *%s_class = (%sClass *)%s;\n", - s,f,s,oname); + out_printf(out, "\t%sClass *%s_class = (%sClass *)%s;\n", + s, f, s, oname); g_free(f); } - g_hash_table_foreach(done,(GHFunc)g_free,NULL); + g_hash_table_foreach(done, (GHFunc)g_free, NULL); g_hash_table_destroy(done); } @@ -811,19 +905,17 @@ make_run_signal_flags(Method *m, gboolean last) char *flag = li->data; int i; for(i=0;flags[i];i++) { - if(strcmp(flags[i],flag)==0) + if(strcmp(flags[i], flag)==0) break; } /* if we haven't found it in our list */ - if(!flags[i]) { - char *s; - s = g_strdup_printf("Unknown flag '%s' used, " - "perhaps it was misspelled", - flag); - print_error(TRUE, s, m->line_no); - g_free(s); + if( ! flags[i]) { + error_printf(GOB_WARN, m->line_no, + "Unknown flag '%s' used, " + "perhaps it was misspelled", + flag); } - g_string_sprintfa(gs, " | GTK_RUN_%s",flag); + g_string_sprintfa(gs, " | GTK_RUN_%s", flag); } { @@ -839,7 +931,7 @@ add_signals(Class *c) { GList *li; - out_printf(out,"\n"); + out_printf(out, "\n"); for(li=c->nodes;li;li=g_list_next(li)) { Node *n = li->data; char *mar, *sig, *flags; @@ -858,54 +950,97 @@ add_signals(Class *c) if(g_hash_table_lookup(marsh, m)) mar = g_strconcat("___marshal_", - (char *)g_hash_table_lookup(marsh,m), + (char *)g_hash_table_lookup(marsh, m), NULL); else 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" + 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, - is_none?0:g_list_length(m->gtktypes->next)); + 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); g_free(flags); - if(!is_none) { + if( ! is_none) { GList *l; - for(l=m->gtktypes->next;l;l=g_list_next(l)) - out_printf(out,",\n\t\t\tGTK_TYPE_%s", + for(l = m->gtktypes->next; l != NULL; l = l->next) + out_printf(out, ",\n\t\t\tGTK_TYPE_%s", (char *)l->data); } - out_printf(out,");\n"); + out_printf(out, ");\n"); + + if(strcmp(m->gtktypes->data, "NONE") != 0 || + ! is_none) { + GList *gl, *al; + char *sep = ""; + out_printf(out, "\tif("); + if(strcmp(m->gtktypes->data, "NONE") != 0) { + out_printf(out, "%s sizeof(", sep); + print_type(out, m->mtype, FALSE); + out_printf(out, "%s", + m->mtype->postfix ? + m->mtype->postfix : ""); + out_printf(out, ") != sizeof(%s)", + get_cast(m->gtktypes->data, FALSE)); + + sep = " || "; + } + + for(al = m->args->next, gl = m->gtktypes->next; + al != NULL && gl != NULL; + al = al->next, gl = gl->next) { + FuncArg *arg = al->data; + char *gtkarg = gl->data; + + out_printf(out, "%ssizeof(", sep); + print_type(out, arg->atype, FALSE); + out_printf(out, "%s", + arg->atype->postfix ? + arg->atype->postfix : ""); + out_printf(out, ") != sizeof(%s)", + get_cast(gtkarg, FALSE)); + + sep = " || "; + } + out_printf(out, ") {\n" + "\t\tg_error(\"%s line %d: Type mismatch " + "of \\\"%s\\\" signal signature\");\n" + "\t}\n", + filename, m->line_no, get_real_id(m->id)); + + } } - out_printf(out,"\tgtk_object_class_add_signals (gtk_object_class,\n" + out_printf(out, "\tgtk_object_class_add_signals (gtk_object_class,\n" "\t\tobject_signals, LAST_SIGNAL);\n\n"); } static void -set_def_handlers(Class *c, char *oname) +set_def_handlers(Class *c, const char *oname) { GList *li; gboolean set_line = FALSE; - out_printf(out,"\n"); - for(li=c->nodes;li;li=g_list_next(li)) { + out_printf(out, "\n"); + 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 && @@ -921,23 +1056,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(get_real_id(m->id), "destroy") == 0) + out_printf(out, "\tgtk_object_class->destroy " + "= ___destroy;\n"); + else if(need_finalize && + finalize_handler && + strcmp(get_real_id(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, get_real_id(m->id), (guint)m->unique_id, + funcbase, get_real_id(m->id)); else - out_printf(out,"\t%s_class->%s = NULL;\n", - s, m->id); + out_printf(out, "\t%s_class->%s = NULL;\n", + s, get_real_id(m->id)); } else { if(m->cbuf) - out_printf(out,"\t%s->%s = ___real_%s_%s;\n", - oname, m->id, funcbase, m->id); + out_printf(out, "\t%s->%s = ___real_%s_%s;\n", + oname, get_real_id(m->id), + funcbase, get_real_id(m->id)); else - out_printf(out,"\t%s->%s = NULL;\n", - oname, m->id); + out_printf(out, "\t%s->%s = NULL;\n", + oname, get_real_id(m->id)); } } if(set_line) @@ -956,7 +1110,7 @@ make_arguments(Class *c) NULL }; - out_printf(out,"\n"); + out_printf(out, "\n"); for(li=c->nodes;li;li=g_list_next(li)) { Node *n = li->data; Argument *a; @@ -974,37 +1128,37 @@ make_arguments(Class *c) flags = g_string_new("GTK_ARG_READABLE"); else flags = g_string_new("GTK_ARG_WRITABLE"); + + g_assert(a->get || a->set); for(l=a->flags;l;l=g_list_next(l)) { char *flag = l->data; int i; - if(strcmp(flag,"READWRITE")==0 || - strcmp(flag,"READABLE")==0 || - strcmp(flag,"WRITABLE")==0) { - print_error(TRUE,"READWRITE, READABLE and " + if(strcmp(flag, "READWRITE")==0 || + strcmp(flag, "READABLE")==0 || + strcmp(flag, "WRITABLE")==0) { + error_print(GOB_WARN, a->line_no, + "READWRITE, READABLE and " "WRITABLE argument flags are " - "set automatically",a->line_no); + "set automatically"); continue; } - for(i=0;argflags[i];i++) { - if(strcmp(argflags[i],flag)==0) + for(i = 0; argflags[i]; i++) { + if(strcmp(argflags[i], flag)==0) break; } /* if we haven't found it in our list */ - if(!argflags[i]) { - char *s; - s = g_strdup_printf("Unknown flag '%s' used, " - "perhaps it was misspelled", - flag); - print_error(TRUE,s,a->line_no); - g_free(s); + if( ! argflags[i]) { + error_printf(GOB_WARN, a->line_no, + "Unknown flag '%s' used, " + "perhaps it was misspelled", flag); } - g_string_sprintfa(flags, " | GTK_ARG_%s",flag); + g_string_sprintfa(flags, " | GTK_ARG_%s", flag); } s = g_strdup(a->name); g_strup(s); - out_printf(out,"\tgtk_object_add_arg_type(\"%s::%s\",\n" + out_printf(out, "\tgtk_object_add_arg_type(\"%s::%s\",\n" "\t\tGTK_TYPE_%s,\n" "\t\t%s,\n" "\t\tARG_%s);\n", @@ -1013,9 +1167,11 @@ make_arguments(Class *c) g_string_free(flags, TRUE); } - out_printf(out, - "\n\tgtk_object_class->set_arg = ___object_set_arg;\n" - "\tgtk_object_class->get_arg = ___object_get_arg;\n"); + out_printf(out, "\n"); + if(get_arguments > 0) + out_printf(out, "\tgtk_object_class->get_arg = ___object_get_arg;\n"); + if(set_arguments > 0) + out_printf(out, "\tgtk_object_class->set_arg = ___object_set_arg;\n"); } static void @@ -1044,6 +1200,146 @@ 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 = %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, "\treturn;\n"); + if(destructors > 0) + out_printf(out, "\tself = NULL;\n"); + 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); + out_printf(out, "\tgpointer priv = self->_priv;\n"); + } + + 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(priv);\n"); + } + + out_printf(out, "}\n" + "#undef __GOB_FUNCTION__\n\n"); +} + static void add_inits(Class *c) { @@ -1051,22 +1347,30 @@ add_inits(Class *c) for(li=c->nodes;li;li=g_list_next(li)) { Node *n = li->data; Method *m; + + gboolean add_unused_class = FALSE; + if(n->type != METHOD_NODE) continue; m = (Method *)n; if(m->method == INIT_METHOD) { if(m->line_no > 0) - out_addline_infile(out,m->line_no); + 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 = " + 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; @@ -1074,59 +1378,114 @@ add_inits(Class *c) li != NULL; li = li->next) { Node *n = li->data; - if(n->type != VARIABLE_NODE) + Variable *v = (Variable *)n; + if(n->type != VARIABLE_NODE || + v->scope == CLASS_SCOPE) continue; - print_initializer(m, (Variable *)n); + print_initializer(m, v); } } } 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 || + set_arguments > 0 || + get_arguments > 0 || + need_destroy || + need_finalize) { + add_unused_class = TRUE; out_printf(out, "\tGtkObjectClass *" "gtk_object_class = " "(GtkObjectClass*) %s;\n", ((FuncArg *)m->args->data)->name); + out_printf(out, + "#ifdef G_OBJECT_CLASS\n" + "\tGObjectClass *" + "g_object_class = " + "(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; + 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_initializer(m, v); + } + } - out_printf(out,"\n\tparent_class = "); + out_printf(out, "\n\tparent_class = "); if(for_cpp) - out_printf(out,"(%sClass *)",ptypebase); - out_printf(out,"gtk_type_class (%s_get_type ());\n", + out_printf(out, "(%sClass *)", ptypebase); + 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(get_arguments > 0 || set_arguments > 0) make_arguments(c); } else continue; if(m->cbuf) { - out_printf(out," {\n"); - out_addline_infile(out,m->ccode_line); - out_printf(out,"%s\n",m->cbuf); + out_printf(out, " {\n"); + out_addline_infile(out, m->ccode_line); + out_printf(out, "%s\n", m->cbuf); out_addline_outfile(out); - out_printf(out," }\n"); - } else { - out_printf(out,"return;\n"); + out_printf(out, " }\n"); + } + out_printf(out, "\treturn;\n"); + out_printf(out, + "\t%s = NULL;\n", + ((FuncArg *)m->args->data)->name); + if(add_unused_class) { + out_printf(out, + "\tgtk_object_class = NULL;\n" + "#ifdef G_OBJECT_CLASS\n" + "\tg_object_class = NULL;\n" + "#endif /* G_OBJECT_CLASS */\n"); } - out_printf(out,"}\n"); + out_printf(out, "}\n" + "#undef __GOB_FUNCTION__\n"); } } @@ -1134,15 +1493,18 @@ static void add_getset_arg(Class *c, gboolean is_set) { GList *li; - out_printf(out,"\nstatic void\n" - "___object_%s_arg (GtkObject *object,\n" - "\tGtkArg *arg,\n" - "\tguint arg_id)\n" - "{\n" - "\t%s *self;\n\n" - "\tself = %s (object);\n\n" - "\tswitch (arg_id) {\n", - is_set?"set":"get",typebase,macrobase); + out_printf(out, "\nstatic void\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", + c->otype, is_set ? "set" : "get", + typebase, macrobase); for(li=c->nodes;li;li=g_list_next(li)) { Node *n = li->data; @@ -1164,43 +1526,58 @@ add_getset_arg(Class *c, gboolean is_set) continue; s = g_strdup(a->name); g_strup(s); + out_printf(out, "\tcase ARG_%s:\n", s); if(is_set && a->atype) { char *cast = get_type(a->atype, TRUE); - out_printf(out, "\tcase ARG_%s:\n", s); if(no_gnu || for_cpp) { out_printf(out, "#define ARG " "((%s)GTK_VALUE_%s(*arg))\n", cast, a->gtktype); } else { - out_printf(out, "#ifdef __GNUC__\n"); - out_printf(out, "#define ARG " - "({%s foo = GTK_VALUE_%s(*arg); " - "foo; })\n", - cast, a->gtktype); - out_printf(out,"#else /* __GNUC__ */\n"); + out_printf(out, "#if defined(__GNUC__) && !defined(__STRICT_ANSI__)\n"); + if(strcmp(a->gtktype, "OBJECT")==0) { + out_printf(out, "#define ARG " + "({%s foo = " + "GTK_VALUE_POINTER(*arg); " + "foo; })\n", + cast); + } else { + out_printf(out, "#define ARG " + "({%s foo = " + "GTK_VALUE_%s(*arg); " + "foo; })\n", + cast, a->gtktype); + } + out_printf(out, "#else /* __GNUC__ && !__STRICT_ANSI__ */\n"); out_printf(out, "#define ARG " "((%s)GTK_VALUE_%s(*arg))\n", cast, a->gtktype); - out_printf(out,"#endif /* __GNUC__ */\n\n"); + out_printf(out, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n\n"); } out_printf(out, "\t\t{\n"); g_free(cast); + } else if(!is_set && strcmp(a->gtktype, "OBJECT")==0) { + out_printf(out, + "#define ARG (GTK_VALUE_POINTER(*arg))\n" + "\t\t{\n"); } else { - out_printf(out, "\tcase ARG_%s:\n" + out_printf(out, "#define ARG (GTK_VALUE_%s(*arg))\n" "\t\t{\n", - s, a->gtktype); + a->gtktype); } g_free(s); if(line_no > 0) out_addline_infile(out, line_no); - out_printf(out,"%s\n",cbuf); + out_printf(out, "%s\n", cbuf); if(line_no > 0) out_addline_outfile(out); - out_printf(out,"\t\t}\n\t\tbreak;\n" + 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" + "\treturn;\n\tself = NULL;\n\targ = NULL;\n}\n" + "#undef __GOB_FUNCTION__\n"); } static void @@ -1209,51 +1586,51 @@ print_checks(Method *m, FuncArg *fa) GList *li; gboolean is_void; gboolean checked_null = FALSE; - is_void = (strcmp(m->mtype->name,"void")==0 && - m->mtype->stars == 0); + is_void = (strcmp(m->mtype->name, "void")==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 */ if(m->line_no > 0) - out_addline_infile(out,m->line_no); + out_addline_infile(out, m->line_no); if(is_void) - out_printf(out,"\tg_return_if_fail ("); + out_printf(out, "\tg_return_if_fail ("); else - out_printf(out,"\tg_return_val_if_fail ("); + out_printf(out, "\tg_return_val_if_fail ("); switch(ch->chtype) { case NULL_CHECK: - out_printf(out,"%s != NULL",fa->name); + out_printf(out, "%s != NULL", fa->name); checked_null = TRUE; break; case TYPE_CHECK: - s = make_pre_macro(fa->atype->name,"IS"); + s = make_pre_macro(fa->atype->name, "IS"); if(checked_null) - out_printf(out,"%s (%s)",s,fa->name); + out_printf(out, "%s (%s)", s, fa->name); else /* if not check null, null may be valid */ - out_printf(out,"!(%s) || %s (%s)",fa->name,s, - fa->name); + out_printf(out, "!(%s) || %s (%s)", fa->name, + s, fa->name); g_free(s); break; case LT_CHECK: - out_printf(out,"%s < %s",fa->name,ch->number); + out_printf(out, "%s < %s", fa->name, ch->number); break; case GT_CHECK: - out_printf(out,"%s > %s",fa->name,ch->number); + out_printf(out, "%s > %s", fa->name, ch->number); break; case LE_CHECK: - out_printf(out,"%s <= %s",fa->name,ch->number); + out_printf(out, "%s <= %s", fa->name, ch->number); break; case GE_CHECK: - out_printf(out,"%s >= %s",fa->name,ch->number); + out_printf(out, "%s >= %s", fa->name, ch->number); break; case EQ_CHECK: - out_printf(out,"%s == %s",fa->name,ch->number); + out_printf(out, "%s == %s", fa->name, ch->number); break; case NE_CHECK: - out_printf(out,"%s != %s",fa->name,ch->number); + out_printf(out, "%s != %s", fa->name, ch->number); break; } if(is_void) @@ -1275,94 +1652,22 @@ print_preconditions(Method *m) for(li=m->args;li;li=g_list_next(li)) { FuncArg *fa = li->data; if(fa->checks) - print_checks(m,fa); + print_checks(m, fa); } if(m->line_no>0) 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; - if(n->type == VARIABLE_NODE) - print_destructor("___self", - (Variable *)n); - } - } - 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 @@ -1375,10 +1680,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 @@ -1386,7 +1695,7 @@ put_signal_args(Method *m) { GList *li; GList *ali; - for(ali = m->gtktypes->next,li=m->args->next; + for(ali = m->gtktypes->next, li=m->args->next; li && ali; li=li->next, ali=ali->next) { FuncArg *fa = li->data; @@ -1395,7 +1704,7 @@ put_signal_args(Method *m) the we know all the types */ g_assert(cast); - out_printf(out,",\n\t\t(%s)%s",cast, + out_printf(out, ",\n\t\t(%s)%s", cast, fa->name); } } @@ -1420,150 +1729,175 @@ get_arg_names_for_macro(Method *m) static void put_method(Method *m) { - char *s,*args,*doc; + char *s, *args, *doc; gboolean is_void; - is_void = (strcmp(m->mtype->name,"void")==0 && - m->mtype->stars == 0); - out_printf(out,"\n"); - doc = get_gtk_doc(m->id); - if(doc) { - out_printf(out, "%s", doc); - g_free(doc); + is_void = (strcmp(m->mtype->name, "void")==0 && + m->mtype->pointer == NULL); + out_printf(out, "\n"); + 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) - out_addline_infile(out,m->line_no); + 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); + print_method(out, "static ", "\n", "", " ", "\n", + 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) - out_addline_infile(out,m->line_no); + 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); + print_method(out, "static ", "\n", "", " ", "\n", + 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); + 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, "\tgtk_signal_emit (GTK_OBJECT (%s),\n" "\t\tobject_signals[%s_SIGNAL]", - ((FuncArg *)m->args->data)->name,s); + ((FuncArg *)m->args->data)->name, s); put_signal_args(m); - out_printf(out,");\n}\n"); + out_printf(out, ");\n}\n"); } else { - out_printf(out,"\t"); - print_type(out,m->mtype,TRUE); - out_printf(out,"return_val;\n"); + out_printf(out, "\t"); + print_type(out, m->mtype, TRUE); + out_printf(out, "return_val = ("); + print_type(out, m->mtype, TRUE); + if(m->defreturn) + out_printf(out, ")(%s);\n", m->defreturn); + else if(m->onerror) + out_printf(out, ")(%s);\n", m->onerror); + else + out_printf(out, ")(0);\n"); print_preconditions(m); - out_printf(out,"\tgtk_signal_emit (GTK_OBJECT (%s),\n" + out_printf(out, "\tgtk_signal_emit (GTK_OBJECT (%s),\n" "\t\tobject_signals[%s_SIGNAL]", - ((FuncArg *)m->args->data)->name,s); + ((FuncArg *)m->args->data)->name, s); put_signal_args(m); - out_printf(out,",\n\t\t&return_val);\n" + out_printf(out, ",\n\t\t&return_val);\n" "\treturn return_val;\n}\n"); } if(!m->cbuf) break; - if(m->line_no>0) - out_addline_infile(out,m->line_no); - print_method(out,"static ","\n___real_",""," ","\n", - m,FALSE,FALSE); - print_method_body(m,FALSE); + if(m->line_no > 0) + out_addline_infile(out, m->line_no); + print_method(out, "static ", "\n___real_", "", " ", "\n", + m, FALSE, FALSE, TRUE); + print_method_body(m, FALSE); + /* the outfile line was added above */ break; case VIRTUAL_METHOD: - if(m->line_no>0) - out_addline_infile(out,m->line_no); + 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); + print_method(out, "static ", "\n", "", " ", "\n", + 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); + 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; - out_printf(out,",%s",fa->name); + out_printf(out, ",%s", fa->name); } - out_printf(out,");\n}\n"); + 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; - out_printf(out,",%s",fa->name); + out_printf(out, ",%s", fa->name); } - out_printf(out,");\n" + out_printf(out, ");\n" "\telse\n" "\t\treturn ("); - print_type(out,m->mtype,TRUE); - out_printf(out,")(%s);\n}\n", - m->onerror?m->onerror:"0"); + print_type(out, m->mtype, TRUE); + if(m->defreturn) + out_printf(out, ")(%s);\n}\n", m->defreturn); + else if(m->onerror) + out_printf(out, ")(%s);\n}\n", m->onerror); + else + out_printf(out, ")(0);\n}\n"); } if(!m->cbuf) break; - if(m->line_no>0) - out_addline_infile(out,m->line_no); - print_method(out,"static ","\n___real_",""," ","\n", - m,FALSE,FALSE); - print_method_body(m,FALSE); + if(m->line_no > 0) + out_addline_infile(out, m->line_no); + print_method(out, "static ", "\n___real_", "", " ", "\n", + 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) - out_addline_infile(out,m->line_no); - print_method(out,"static ","\n",""," ","\n", - m,FALSE,FALSE); - s = replace_sep(m->otype,'_'); + if(m->line_no > 0) + out_addline_infile(out, m->line_no); + 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); if(is_void) { - out_printf(out,"#define PARENT_HANDLER(%s) \\\n" + out_printf(out, "#define PARENT_HANDLER(%s) \\\n" "\t{ if(%s_CLASS(parent_class)->%s) \\\n" "\t\t(* %s_CLASS(parent_class)->%s)(%s); }\n", - args,s,m->id,s,m->id,args); + args, s, get_real_id(m->id), s, get_real_id(m->id), args); } else { - out_printf(out,"#define PARENT_HANDLER(%s) \\\n" + out_printf(out, "#define PARENT_HANDLER(%s) \\\n" "\t((%s_CLASS(parent_class)->%s)? \\\n" "\t\t(* %s_CLASS(parent_class)->%s)(%s): \\\n" "\t\t(", - args,s,m->id,s,m->id,args); - out_printf(out,"("); - print_type(out,m->mtype,TRUE); - out_printf(out,")%s))\n", + args, s, get_real_id(m->id), s, get_real_id(m->id), args); + out_printf(out, "("); + print_type(out, m->mtype, TRUE); + out_printf(out, ")%s))\n", m->onerror?m->onerror:"0"); } g_free(args); g_free(s); - print_method_body(m,TRUE); - out_printf(out,"#undef PARENT_HANDLER\n"); + print_method_body(m, TRUE); + /* the outfile line was added above */ + out_printf(out, "#undef PARENT_HANDLER\n"); break; default: break; @@ -1573,19 +1907,20 @@ put_method(Method *m) static void open_files(void) { - char *outfile,*outfileh,*outfileph; + char *outfile, *outfileh, *outfileph; if(!for_cpp) - outfile = g_strconcat(filebase,".c",NULL); + outfile = g_strconcat(filebase, ".c", NULL); else - outfile = g_strconcat(filebase,".cc",NULL); + outfile = g_strconcat(filebase, ".cc", NULL); if(no_touch_headers) - outfileh = g_strconcat("#gob#",filebase,".h#gob#",NULL); + outfileh = g_strconcat("#gob#", filebase, ".h#gob#", NULL); else outfileh = g_strconcat(filebase, ".h", NULL); - if((privates > 0 || protecteds > 0 || always_private_header) && - !no_private_header) + if((privates > 0 || protecteds > 0 || + private_header == PRIVATE_HEADER_ALWAYS) && + private_header != PRIVATE_HEADER_NEVER) outfileph = g_strconcat(filebase, "-private.h", NULL); else outfileph = NULL; @@ -1620,7 +1955,7 @@ put_argument_nongnu_wrappers(Class *c) { GList *li; - if(arguments<0) + if(get_arguments < 0 && set_arguments < 0) return; for(li=c->nodes;li;li=g_list_next(li)) { @@ -1669,7 +2004,7 @@ put_argument_gnu_wrappers(Class *c) { GList *li; - if(arguments<0) + if(get_arguments < 0 && set_arguments < 0) return; for(li=c->nodes;li;li=g_list_next(li)) { @@ -1682,7 +2017,7 @@ put_argument_gnu_wrappers(Class *c) s = g_strdup(a->name); g_strup(s); if(a->atype) - cast = get_type(a->atype,TRUE); + cast = get_type(a->atype, TRUE); else cast = g_strdup(get_cast(a->gtktype, TRUE)); if(cast) { @@ -1740,7 +2075,7 @@ print_ccode_block(CCode *cc) default: case C_CCODE: fp = out; - out_printf(fp,"\n"); + out_printf(fp, "\n"); out_addline_infile(fp, cc->line_no); break; case PH_CCODE: @@ -1788,76 +2123,107 @@ print_class_block(Class *c) out_printf(outh, "\n/*\n" " * Type checking and casting macros\n" " */\n"); - out_printf(outh,"#define %s\t" + out_printf(outh, "#define %s\t" "(%s_get_type())\n", - macrotype,funcbase); - out_printf(outh,"#define %s(obj)\t" - "GTK_CHECK_CAST((obj),%s_get_type(),%s)\n", - macrobase,funcbase,typebase); - out_printf(outh,"#define %s_CLASS(klass)\t" - "GTK_CHECK_CLASS_CAST((klass),%s_get_type(),%sClass)\n", - macrobase,funcbase,typebase); - out_printf(outh,"#define %s(obj)\t" + macrotype, funcbase); + out_printf(outh, "#define %s(obj)\t" + "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", + macrobase, funcbase, typebase); + out_printf(outh, "#define %s(obj)\t" "GTK_CHECK_TYPE((obj), %s_get_type ())\n\n", - macrois,funcbase); - - 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); + 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"); - 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); + 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" " * Main object structure\n" " */\n"); - s = replace_sep(c->otype,'_'); + s = replace_sep(c->otype, '_'); g_strup(s); - out_printf(outh,"#ifndef __TYPEDEF_%s__\n" - "#define __TYPEDEF_%s__\n",s,s); + out_printf(outh, "#ifndef __TYPEDEF_%s__\n" + "#define __TYPEDEF_%s__\n", s, s); g_free(s); - out_printf(outh,"typedef struct _%s %s;\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)) { + out_printf(outh, "typedef struct _%s %s;\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)) { 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) { - out_printf(outh,"\t/*< public >*/\n"); + if( ! printed_public) { + out_printf(outh, "\t/*< public >*/\n"); printed_public = TRUE; } - put_variable((Variable *)n,outh); + put_variable((Variable *)n, outh); } } /* 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) { - out_printf(outh,"\t/*< private >*/\n"); + if( ! printed_private) { + out_printf(outh, "\t/*< private >*/\n"); printed_private = TRUE; } - put_variable((Variable *)n,outh); + put_variable((Variable *)n, outh); } } - if(privates>0) { - if(!printed_private) - out_printf(outh,"\t/*< private >*/\n"); - out_printf(outh,"\t%sPrivate *_priv;\n",typebase); + 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"); + out_printf(outh, "};\n"); - if(privates>0) { + if(privates > 0) { FILE *outfp; /* if we are to stick this into the private @@ -1868,42 +2234,52 @@ print_class_block(Class *c) else outfp = out; - out_printf(outfp,"struct _%sPrivate {\n", + 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 && v->scope == PRIVATE_SCOPE) { - out_addline_infile(outfp,v->line_no); - put_variable(v,outfp); + out_addline_infile(outfp, v->line_no); + put_variable(v, outfp); } } out_addline_outfile(outfp); - out_printf(outfp,"};\n"); + out_printf(outfp, "};\n"); } out_printf(outh, "\n/*\n" " * Class definition\n" " */\n"); - out_printf(outh,"typedef struct _%sClass %sClass;\n", - typebase,typebase); + out_printf(outh, "typedef struct _%sClass %sClass;\n", + typebase, typebase); out_printf(outh, "struct _%sClass {\n\t%sClass __parent__;\n", - typebase,ptypebase); - for(l=c->nodes;l;l=g_list_next(l)) { + typebase, ptypebase); + for(l = c->nodes; l != NULL; l = l->next) { Node *n = l->data; if(n->type == METHOD_NODE) put_vs_method((Method *)n); } - out_printf(outh,"};\n\n"); + /* put class scope variables */ + for(l = c->nodes; l != NULL; l = l->next) { + Node *n = l->data; + Variable *v = (Variable *)n; + if(n->type == VARIABLE_NODE && + v->scope == CLASS_SCOPE) + put_variable((Variable *)n, outh); + } + out_printf(outh, "};\n\n"); - out_printf(out,"/* here are local prototypes */\n"); - if(arguments>0) { - out_printf(out,"static void ___object_set_arg " + out_printf(out, "/* here are local prototypes */\n"); + if(set_arguments > 0) { + out_printf(out, "static void ___object_set_arg " "(GtkObject *object, GtkArg *arg, " - "guint arg_id);\n" - "static void ___object_get_arg " + "guint arg_id);\n"); + } + if(get_arguments > 0) { + out_printf(out, "static void ___object_get_arg " "(GtkObject *object, GtkArg *arg, " "guint arg_id);\n"); } @@ -1912,8 +2288,14 @@ print_class_block(Class *c) " * Public methods\n" " */\n"); - out_printf(outh,"guint\t%s_get_type\t(void);\n",funcbase); - for(l=c->nodes;l;l=g_list_next(l)) { + out_printf(outh, "GtkType\t%s_get_type\t(void)", funcbase); + if ( ! no_gnu) { + out_printf(outh, " G_GNUC_CONST;\n"); + } else { + out_printf(outh, ";\n"); + } + + for(l = c->nodes; l != NULL; l = l->next) { Node *n = l->data; if(n->type == METHOD_NODE) { put_pub_method((Method *)n); @@ -1941,24 +2323,26 @@ print_class_block(Class *c) /* argument wrapping macros */ - if(arguments>0 && !no_gnu) { - out_printf(outh, "\n/*\n" - " * Argument wrapping macros\n" - " */\n"); - out_printf(outh,"#ifdef __GNUC__\n"); - put_argument_gnu_wrappers(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) { - out_printf(outh, "\n/*\n" - " * Argument wrapping macros\n" - " */\n"); - put_argument_nongnu_wrappers(c); + if(get_arguments > 0 || set_arguments > 0) { + if( ! no_gnu) { + out_printf(outh, "\n/*\n" + " * Argument wrapping macros\n" + " */\n"); + out_printf(outh, "#if defined(__GNUC__) && !defined(__STRICT_ANSI__)\n"); + put_argument_gnu_wrappers(c); + out_printf(outh, "#else /* __GNUC__ && !__STRICT_ANSI__ */\n"); + put_argument_nongnu_wrappers(c); + out_printf(outh, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n\n"); + } else { + 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); @@ -1970,30 +2354,37 @@ print_class_block(Class *c) add_get_type(); if(any_method_to_alias(c)) { - if(no_gnu) - make_method_nongnu_aliases(c); - else { - out_printf(out,"\n#ifdef __GNUC__\n"); + if( ! no_gnu) { + out_printf(out, "/* Short form macros */\n"); + out_printf(out, "#if defined(__GNUC__) && !defined(__STRICT_ANSI__)\n"); make_method_gnu_aliases(c); - out_printf(out,"#else /* __GNUC__ */\n"); - make_method_nongnu_aliases(c); - out_printf(out,"#endif /* __GNUC__ */\n\n"); + out_printf(out, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n"); } + make_method_nongnu_aliases(c); } - out_printf(out,"/* a macro for creating a new object of our type */\n"); + out_printf(out, "/* a macro for creating a new object of our type */\n"); out_printf(out, "#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(set_arguments > 0) { add_getset_arg(c, TRUE); + } + + if(get_arguments > 0) { 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); @@ -2026,6 +2417,8 @@ print_file_comments(void) out_printf(out, "/* Generated by GOB (v%s) on %s" " (do not edit directly) */\n\n", VERSION, ctime(&curtime)); + + out_printf(out, "/* End world hunger, donate to the World Food Programme, http://www.wfp.org */\n\n"); } static void @@ -2034,9 +2427,15 @@ print_includes(void) gboolean found_header; char *p; + /* We may need string.h for memset */ + if(destructors > 0 && + ! g_list_find_custom(include_files, "string.h", (GCompareFunc)strcmp)) { + 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)) { + if( ! g_list_find_custom(include_files, p, (GCompareFunc)strcmp)) { out_printf(out, "#include \"%s.h\"\n\n", filebase); found_header = FALSE; } @@ -2045,11 +2444,12 @@ print_includes(void) /* if we are creating a private header see if it was included */ if(outph) { p = g_strconcat(filebase, "-private.h", NULL); - if(!g_list_find_custom(include_files, p, (GCompareFunc)strcmp)) { - out_printf(out,"#include \"%s-private.h\"\n\n", + if( ! g_list_find_custom(include_files, p, + (GCompareFunc)strcmp)) { + out_printf(out, "#include \"%s-private.h\"\n\n", filebase); if(found_header) - print_error(TRUE, + error_printf(GOB_WARN, 0, "Implicit private header include " "added to top of\n" "\tsource file, while public " @@ -2057,7 +2457,7 @@ print_includes(void) "you should\n" "\texplicitly include " "the private header below the " - "public one.", 0); + "public one."); } g_free(p); } @@ -2077,7 +2477,7 @@ print_header_prefixes(void) "#include \"%s.h\"\n\n", p, p, filebase); g_free(p); - if(!no_extern_c) { + if( ! no_extern_c) { out_printf(outh, "#ifdef __cplusplus\n" "extern \"C\" {\n" "#endif /* __cplusplus */\n\n"); @@ -2091,17 +2491,17 @@ print_header_prefixes(void) static void print_header_postfixes(void) { - if(!no_extern_c) - out_printf(outh,"\n#ifdef __cplusplus\n" + if( ! no_extern_c) + out_printf(outh, "\n#ifdef __cplusplus\n" "}\n" "#endif /* __cplusplus */\n"); - out_printf(outh,"\n#endif"); + out_printf(outh, "\n#endif\n"); if(outph) { - if(!no_extern_c) - out_printf(outph,"\n#ifdef __cplusplus\n" + if( ! no_extern_c) + out_printf(outph, "\n#ifdef __cplusplus\n" "}\n" "#endif /* __cplusplus */\n"); - out_printf(outph,"\n#endif"); + out_printf(outph, "\n#endif\n"); } } @@ -2111,11 +2511,11 @@ print_all_top(void) GList *li; /* print the AT_CCODE blocks */ - 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) { CCode *cc = (CCode *)node; - if(cc->cctype==AT_CCODE) + if(cc->cctype == AT_CCODE) print_ccode_block((CCode *)node); } } @@ -2127,14 +2527,14 @@ print_header_top(void) GList *li; /* mandatory include */ - out_printf(outh,"#include \n\n"); + out_printf(outh, "#include \n\n"); /* print the HT_CCODE blocks */ for(li=nodes;li;li=g_list_next(li)) { Node *node = li->data; if(node->type == CCODE_NODE) { CCode *cc = (CCode *)node; - if(cc->cctype==HT_CCODE) + if(cc->cctype == HT_CCODE) print_ccode_block((CCode *)node); } } @@ -2161,7 +2561,8 @@ generate_outfiles(void) Node *node = li->data; if(node->type == CCODE_NODE) { CCode *cc = (CCode *)node; - if(cc->cctype!=HT_CCODE) + 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); @@ -2175,8 +2576,9 @@ generate_outfiles(void) static void print_help(void) { - fprintf(stderr,"Gob version %s\n\n",VERSION); - fprintf(stderr,"Options:\n" + 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" "\t--exit-on-warn,-w Exit with an error on warnings\n" @@ -2189,14 +2591,25 @@ print_help(void) "really changed\n" "\t--always-private-header Always create a private header " "file,\n" - "\t even if it would be empty\n" + "\t even if it would be empty " + "[default]\n" + "\t--ondemand-private-header Create private header only when " + "needed\n" "\t--no-private-header Don't create a private header, " "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 @@ -2208,8 +2621,9 @@ parse_options(int argc, char *argv[]) filename = NULL; - for(i=1;i /dev/null", hf, hfnew); - if(system(s)==0) { - if(unlink(hfnew)!=0) - print_error(FALSE, - "Can't remove new header file", 0); + if(system(s) == 0) { + if(unlink(hfnew) != 0) + error_printf(GOB_ERROR, 0, + "Can't remove new header file"); g_free(hfnew); g_free(hf); g_free(s); return; } g_free(s); - if(unlink(hf)!=0) - print_error(FALSE, "Can't remove old header file", 0); + if(unlink(hf) != 0) + error_printf(GOB_ERROR, 0, + "Can't remove old header file"); } - if(rename(hfnew,hf)!=0) - print_error(FALSE, "Can't rename new header file", 0); + if(rename(hfnew, hf) != 0) + error_printf(GOB_ERROR, 0, + "Can't rename new header file"); g_free(hfnew); g_free(hf); } @@ -2325,17 +2747,20 @@ main(int argc, char *argv[]) } else filename = "stdin"; + /* This is where parsing is done */ /*yydebug = 1;*/ - if(yyparse()!=0) + if(yyparse() != 0) g_error("Parsing errors, quitting"); - if(!class) - print_error(FALSE, " no class defined", 0); + + if( ! class) + error_print(GOB_ERROR, 0, " no class defined"); exit_on_error = FALSE; signals = count_signals((Class *)class); - arguments = count_arguments((Class *)class); + set_arguments = count_set_arguments((Class *)class); + get_arguments = count_get_arguments((Class *)class); overrides = count_overrides((Class *)class); privates = count_privates((Class *)class); protecteds = count_protecteds((Class *)class); @@ -2344,10 +2769,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); @@ -2355,6 +2787,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; @@ -2376,7 +2809,8 @@ main(int argc, char *argv[]) fclose(outph); } - if(no_touch_headers && !no_write) + if(no_touch_headers && + ! no_write) compare_and_move_header(); return 0;