X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/dd11885aadcfaafae2d6268c381b0aac94cbc149..77fd2f2194af12f95959506910f3babe842c5f1f:/src/main.c diff --git a/src/main.c b/src/main.c index 09f59c2..6b233d7 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 * @@ -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,35 @@ 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, - gboolean one_arg_per_line, - gboolean no_funcbase) +print_method (FILE *fp, + const char *typeprefix, + const char *nameprefix, + const char *subnameprefix, + const char *namepostfix, + const char *afterargs, + const char *postfix, + const Method *m, + gboolean one_arg_per_line, + 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,21 +230,21 @@ 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"); } - out_printf(fp, ")%s", postfix); + out_printf(fp, "%s)%s", afterargs, postfix); } static gboolean @@ -242,12 +269,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 +289,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 +305,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 +322,22 @@ 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 +346,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 +359,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 +371,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,69 +408,78 @@ 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 */ -#if 0 static void -put_signal_connect(Method *m) +put_signal_macro (const Method *m, gboolean gnu) { + char *id; + if(m->method != SIGNAL_LAST_METHOD && m->method != SIGNAL_FIRST_METHOD) return; - out_printf(outh, "guint \t%s_%s__connect_full\t(%s *object,\n" - "\t\t\t\t\tconst char *name,\n" - "\t\t\t\t\tGtkSignalFunc func,\n" - "\t\t\t\t\tGtkCallbackMarshal marshal,\n" - "\t\t\t\t\tgpointer data,\n" - "\t\t\t\t\tGtkDestroyNotify destroy_func,\n" - "\t\t\t\t\tgboolean object_signal,\n" - "\t\t\t\t\tgboolean after);\n", - funcbase, m->id, typebase); - - out_printf(outh, "#define %s_%s__connect(object,name,func,data) " - "%s_%s__connect_full((object),(name),(func),NULL," - "(data),NULL,FALSE,FALSE)\n", - funcbase, m->id, funcbase, m->id); - out_printf(outh, "#define %s_%s__connect_after(object,name,func,data) " - "%s__connect_%s_full((object),(name),(func),NULL," - "(data),NULL,FALSE,TRUE)\n", - funcbase, m->id, funcbase, m->id); - - out_printf(outh, "guint \t%s_%s__connect_while_alive\t(%s *object,\n" - "\t\t\t\t\tconst char *name,\n" - "\t\t\t\t\tGtkSignalFunc func,\n" - "\t\t\t\t\tgpointer data,\n" - "\t\t\t\t\tGtkObject *alive_object);\n\n", - funcbase, m->id, typebase); + id = g_strdup (m->id); + g_strup (id); + + if ( ! gnu) { + out_printf (outh, "#define %s_SIGNAL_%s(func)\t" + "\"%s\",GTK_SIGNAL_FUNC(func)\n", + macrobase, id, get_real_id (m->id)); + } else { + out_printf (outh, "#define %s_SIGNAL_%s(func)\t" + "\"%s\",GTK_SIGNAL_FUNC(({", + macrobase, id, get_real_id (m->id)); + print_method (outh, "", "(* ___", "", ") ", ", gpointer data ", + " = func; ", m, FALSE, TRUE, TRUE); + out_printf (outh, "___%s; }))\n", get_real_id (m->id)); + + } + g_free (id); +} + +static void +put_signal_macros (const Class *c, gboolean gnu) +{ + const GList *li; + + if (signals < 0) + return; + + for (li = c->nodes; li != NULL; li = li->next) { + const Node *n = li->data; + if (n->type == METHOD_NODE) + put_signal_macro ((Method *)n, gnu); + } } -#endif 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 @@ -440,18 +490,26 @@ put_priv_method_prot(Method *m) m->method == VIRTUAL_METHOD) { if(m->cbuf) print_method(out, - "static ", "___real_", "", " ", ";\n", - m, FALSE, FALSE); + "static ", "___real_", "", " ", "", ";\n", + 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)) - print_method(out, "static ", "", "", " ", + 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); + 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, TRUE); } static GList * @@ -462,12 +520,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 +542,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, 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, 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, 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 +651,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 +667,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; @@ -589,16 +679,16 @@ print_signal_marsal_args(Method *m) 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,7 +709,7 @@ 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) @@ -628,12 +718,12 @@ add_signal_prots(Method *m) /* 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); @@ -648,12 +738,12 @@ add_signal_prots(Method *m) } 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) { out_printf(out, "\t___%s rfunc;\n\n" @@ -678,33 +768,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); } } @@ -716,46 +806,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; @@ -764,24 +867,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); } @@ -814,19 +917,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); } { @@ -842,7 +943,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; @@ -861,54 +962,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 && @@ -924,23 +1068,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) @@ -959,7 +1122,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; @@ -977,37 +1140,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", @@ -1016,9 +1179,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 @@ -1047,6 +1212,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) { @@ -1054,22 +1359,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); - print_method(out, "static ", "\n", "", " ", "\n", - m, FALSE, FALSE); + out_addline_infile(out, m->line_no); + print_method(out, "static ", "\n", "", " ", "", "\n", + 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; @@ -1077,59 +1390,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); + print_method(out, "static ", "\n", "", " ", "", "\n", + 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"); } } @@ -1137,15 +1505,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; @@ -1175,7 +1546,7 @@ add_getset_arg(Class *c, gboolean is_set) "((%s)GTK_VALUE_%s(*arg))\n", cast, a->gtktype); } else { - out_printf(out, "#ifdef __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 = " @@ -1189,11 +1560,11 @@ add_getset_arg(Class *c, gboolean is_set) "foo; })\n", cast, a->gtktype); } - out_printf(out,"#else /* __GNUC__ */\n"); + 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); @@ -1210,13 +1581,15 @@ add_getset_arg(Class *c, gboolean is_set) 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 @@ -1226,14 +1599,14 @@ 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 */ 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 ("); else @@ -1254,22 +1627,22 @@ print_checks(Method *m, FuncArg *fa) 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) @@ -1291,94 +1664,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 @@ -1391,10 +1692,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 @@ -1402,7 +1707,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; @@ -1411,7 +1716,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); } } @@ -1436,50 +1741,54 @@ 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); + print_method(out, "", "\n", "", " ", "", "\n", + 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); @@ -1492,54 +1801,59 @@ put_method(Method *m) 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" "\telse\n" @@ -1555,42 +1869,47 @@ put_method(Method *m) 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; @@ -1600,19 +1919,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; @@ -1647,7 +1967,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)) { @@ -1696,7 +2016,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)) { @@ -1709,7 +2029,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) { @@ -1767,7 +2087,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: @@ -1815,76 +2135,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 @@ -1895,42 +2246,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"); } @@ -1939,8 +2300,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); @@ -1949,43 +2316,40 @@ print_class_block(Class *c) } } -/* this idea is less and less apealing to me */ -#if 0 - if(!no_signal_connect) { - if(signals>0) { - out_printf(outh, "\n/*\n" - " * Signal connection methods\n" - " */\n"); - } - - for(l=c->nodes;l;l=g_list_next(l)) { - Node *n = l->data; - if(n->type == METHOD_NODE) - put_signal_connect((Method *)n); + /* this idea is less and less apealing to me */ + if (signals > 0) { + out_printf (outh, "\n/*\n" + " * Signal connection wrapper macros\n" + " */\n"); + if( ! no_gnu) { + out_printf(outh, "#if defined(__GNUC__) && !defined(__STRICT_ANSI__)\n"); + put_signal_macros (c, TRUE); + out_printf(outh, "#else /* __GNUC__ && !__STRICT_ANSI__ */\n"); + put_signal_macros (c, FALSE); + out_printf(outh, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n\n"); + } else { + put_signal_macros (c, FALSE); } } -#endif - /* 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) { + if(get_arguments > 0 || set_arguments > 0) { out_printf(outh, "\n/*\n" " * Argument wrapping macros\n" " */\n"); - put_argument_nongnu_wrappers(c); + if( ! no_gnu) { + 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 { + 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); @@ -1997,30 +2361,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); @@ -2053,6 +2424,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 @@ -2061,9 +2434,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; } @@ -2072,11 +2451,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 " @@ -2084,7 +2464,7 @@ print_includes(void) "you should\n" "\texplicitly include " "the private header below the " - "public one.", 0); + "public one."); } g_free(p); } @@ -2104,7 +2484,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"); @@ -2118,13 +2498,13 @@ print_header_prefixes(void) static void print_header_postfixes(void) { - if(!no_extern_c) + if( ! no_extern_c) out_printf(outh, "\n#ifdef __cplusplus\n" "}\n" "#endif /* __cplusplus */\n"); out_printf(outh, "\n#endif\n"); if(outph) { - if(!no_extern_c) + if( ! no_extern_c) out_printf(outph, "\n#ifdef __cplusplus\n" "}\n" "#endif /* __cplusplus */\n"); @@ -2138,11 +2518,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); } } @@ -2154,14 +2534,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); } } @@ -2188,7 +2568,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); @@ -2202,8 +2583,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" @@ -2216,14 +2598,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 @@ -2235,8 +2628,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); } @@ -2352,17 +2754,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); @@ -2371,10 +2776,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); @@ -2382,6 +2794,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; @@ -2403,7 +2816,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;