Changeset 6100

Timestamp:

03/07/09 14:20:39 (3 years ago)

Author:

westram

Message:

• fix warning "format not a string literal and no format arguments"
  • GB_export_error -> GB_export_error/GB_export_errorf

Location:

trunk

Files:

• ARBDB/adGene.c (modified) (1 diff)
• ARBDB/adRevCompl.c (modified) (1 diff)
• ARBDB/ad_load.c (modified) (2 diffs)
• ARBDB/ad_prot.h (modified) (1 diff)
• ARBDB/ad_save_load.c (modified) (10 diffs)
• ARBDB/adali.c (modified) (5 diffs)
• ARBDB/adcomm.c (modified) (20 diffs)
• ARBDB/adcompr.c (modified) (1 diff)
• ARBDB/adindex.c (modified) (1 diff)
• ARBDB/aditem.c (modified) (2 diffs)
• ARBDB/adlang1.c (modified) (3 diffs)
• ARBDB/adlink.c (modified) (2 diffs)
• ARBDB/admap.c (modified) (1 diff)
• ARBDB/admatch.c (modified) (2 diffs)
• ARBDB/adname.c (modified) (1 diff)
• ARBDB/adquery.c (modified) (5 diffs)
• ARBDB/adseqcompr.c (modified) (2 diffs)
• ARBDB/adsocket.c (modified) (6 diffs)
• ARBDB/adstring.c (modified) (9 diffs)
• ARBDB/adtables.c (modified) (3 diffs)
• ARBDB/adtools.c (modified) (2 diffs)
• ARBDB/adtree.c (modified) (3 diffs)
• ARBDB/arbdb.c (modified) (13 diffs)
• AWT/AWT_csp.cxx (modified) (1 diff)
• AWT/AWT_input_mask.cxx (modified) (5 diffs)
• AWT/AWT_nds.cxx (modified) (2 diffs)
• AWT/AWT_query_and_functions.cxx (modified) (1 diff)
• AWT/AWT_seq_colors.cxx (modified) (1 diff)
• AWT/AWT_tree.cxx (modified) (1 diff)
• AWT/AWT_www.cxx (modified) (1 diff)
• AWT/awt_input_mask_internal.hxx (modified) (2 diffs)
• AWTI/AWTI_import.cxx (modified) (2 diffs)
• DIST/DI_matr.cxx (modified) (2 diffs)
• DIST/DI_mldist.cxx (modified) (1 diff)
• DIST/DI_protdist.cxx (modified) (2 diffs)
• EDIT/edit.cxx (modified) (1 diff)
• EDIT4/ED4_ProteinViewer.cxx (modified) (1 diff)
• EDIT4/ED4_no_class.cxx (modified) (2 diffs)
• EDIT4/ED4_protein_2nd_structure.cxx (modified) (1 diff)
• GENOM/EXP_interface.cxx (modified) (3 diffs)
• GENOM/GEN_interface.cxx (modified) (2 diffs)
• GENOM/GEN_map.cxx (modified) (2 diffs)
• MERGE/MG_gene_species.cxx (modified) (1 diff)
• MERGE/MG_preserves.cxx (modified) (1 diff)
• MERGE/MG_species.cxx (modified) (1 diff)
• NTREE/AP_consensus.cxx (modified) (1 diff)
• NTREE/AP_csp_2_gnuplot.cxx (modified) (2 diffs)
• NTREE/NT_concatenate.cxx (modified) (1 diff)
• PARSIMONY/AP_tree_edge.cxx (modified) (1 diff)
• PARSIMONY/PARS_main.cxx (modified) (1 diff)
• PERL2ARB/ARB_ext.c (modified) (1 diff)
• PRIMER_DESIGN/primer_design.cxx (modified) (2 diffs)
• PROBE_DESIGN/probe_design.cxx (modified) (4 diffs)
• SECEDIT/SEC_graphic.cxx (modified) (2 diffs)
• SECEDIT/SEC_main.cxx (modified) (2 diffs)
• SERVERCNTRL/servercntrl.c (modified) (4 diffs)
• SL/AW_NAME/AW_rename.cxx (modified) (2 diffs)
• SL/FAST_ALIGNER/fast_aligner.cxx (modified) (8 diffs)
• SL/TREE_READ/TreeRead.cxx (modified) (1 diff)
• SL/TREE_WRITE/TreeWrite.cxx (modified) (2 diffs)
• WINDOW/AW_nawar.cxx (modified) (1 diff)
• WINDOW/AW_window.cxx (modified) (4 diffs)

trunk/ARBDB/adGene.c

@@ -569 +569 @@
     gb_assert(GEN_find_origin_organism(gb_pseudo, 0) == 0);
 
-    error = GB_export_error("The gene-species '%s' refers to an unknown organism (%s)\n"
-                            "This occurs if you rename or delete the organism or change the entry\n"
-                            "'ARB_origin_species' and will most likely cause serious problems.",
-                            GBT_read_name(gb_pseudo),
-                            GEN_origin_organism(gb_pseudo));
+    error = GB_export_errorf("The gene-species '%s' refers to an unknown organism (%s)\n"
+                             "This occurs if you rename or delete the organism or change the entry\n"
+                             "'ARB_origin_species' and will most likely cause serious problems.",
+                             GBT_read_name(gb_pseudo),
+                             GEN_origin_organism(gb_pseudo));
 
     return error;

trunk/ARBDB/adRevCompl.c

@@ -105 +105 @@
         default: {
             *T_or_U = 0;
-            return GB_export_error("%s not available for alignment-type", supposed_target);
+            return GB_export_errorf("%s not available for alignment-type", supposed_target);
         }
     }

trunk/ARBDB/ad_load.c

@@ -714 +714 @@
     if (!GBCONTAINER_MAIN(gbd)->allow_corrupt_file_recovery) {
         if (!recovery_reason) { recovery_reason = GB_await_error(); }
-        GB_export_error("Aborting recovery (because recovery mode is disabled)\n"
-                        "Error causing recovery: '%s'\n"
-                        "Part of data may be recovered using 'arb_repair yourDB.arb newName.arb'\n"
-                        "(Note: Recovery doesn't work if the error occurs while loading a quick save file)",
-                        recovery_reason);
-        /*         GB_export_error("Your data file is corrupt.\n" */
-        /*                         "   This may happen if \n" */
-        /*                         "   - there is a hardware error (e.g a drive crash),\n" */
-        /*                         "   - data is corrupted by bad internet connections,\n" */
-        /*                         "   - data is destroyed by the program or\n" */
-        /*                         "   - if it isn't an arb file\n" */
-        /*                         "   You may recover part of your data by running\n" */
-        /*                         "       arb_repair old_arb_file panic.arb\n"); */
+        GB_export_errorf("Aborting recovery (because recovery mode is disabled)\n"
+                         "Error causing recovery: '%s'\n"
+                         "Part of data may be recovered using 'arb_repair yourDB.arb newName.arb'\n"
+                         "(Note: Recovery doesn't work if the error occurs while loading a quick save file)",
+                         recovery_reason);
         return -1;
     }
@@ -1198 +1190 @@
             }
             else {
-                GB_export_error("FastLoad-File index conflict (%s)", map_path);
+                GB_export_errorf("FastLoad-File index conflict (%s)", map_path);
             }
         }

trunk/ARBDB/ad_prot.h

@@ -37 +37 @@
 char *GB_find_latest_file P_((const char *dir, const char *mask));
 void GB_raise_critical_error P_((const char *msg));
-GB_ERROR GB_export_error P_((const char *templat, ...)) __ATTR__FORMAT(1);
+GB_ERROR GB_export_error P_((const char *error));
+GB_ERROR GB_export_errorf P_((const char *templat, ...)) __ATTR__FORMAT(1);
 GB_ERROR GB_export_IO_error P_((const char *action, const char *filename));
 GB_ERROR GB_print_error P_((void));

trunk/ARBDB/ad_save_load.c

@@ -148 +148 @@
     }
     else {
-        error = GB_export_error("WARNING: Cannot create file '%s'\n"
-                                "   Your database is saved, but you should check write permissions\n"
-                                "   in the destination directory",
-                                fullref);
+        error = GB_export_errorf("WARNING: Cannot create file '%s'\n"
+                                 "   Your database is saved, but you should check write permissions\n"
+                                 "   in the destination directory",
+                                 fullref);
     }
 
@@ -171 +171 @@
     }
     else {
-        error = GB_export_error("Cannot add your file '%s'\n"
-                                "   to the list of references of '%s'\n"
-                                "   Please ask the owner of that file not to delete it\n"
-                                "   or save the entire database (that's recommended!)",
-                                fullchanges,fullref);
+        error = GB_export_errorf("Cannot add your file '%s'\n"
+                                 "   to the list of references of '%s'\n"
+                                 "   Please ask the owner of that file not to delete it\n"
+                                 "   or save the entire database (that's recommended!)",
+                                 fullchanges,fullref);
     }
 
@@ -623 +623 @@
 {
     long p = (long)ftell(in);
-    GB_export_error("%s in reading GB_file (loc %li=%lX) reading %s\n",
+    GB_export_errorf("%s in reading GB_file (loc %li=%lX) reading %s\n",
                     text,p,p,GB_KEY(gbd));
     GB_print_error();
@@ -1125 +1125 @@
     fmaster = fopen( Main->path, "r" ); /* old master !!!! */
     if (!fmaster){      /* Oh no, where is my old master */
-        return GB_export_error("Save Changes is missing master ARB file '%s',\n"
-                               "    save database first", Main->path);
+        return GB_export_errorf("Save Changes is missing master ARB file '%s',\n"
+                                "    save database first", Main->path);
     }
     fclose(fmaster);
     if (GB_unlink(path)<0){
-        return GB_export_error("File '%s' already exists and cannot be deleted\n(Reason: %s)",path, GB_await_error());
+        return GB_export_errorf("File '%s' already exists and cannot be deleted\n(Reason: %s)",path, GB_await_error());
     };      /* delete old file */
 
@@ -1209 +1209 @@
     if (refpath && strcmp(refpath, Main->path) )
     {
-        return GB_export_error("Internal ARB Error, master file rename '%s'!= '%s',\n"
-                               "    save database first", refpath,Main->path);
+        return GB_export_errorf("Internal ARB Error, master file rename '%s'!= '%s',\n"
+                                "    save database first", refpath,Main->path);
     }
 
@@ -1217 +1217 @@
     if (!fmaster) /* Oh no, where is my old master */
     {
-        return GB_export_error("Quick save is missing master ARB file '%s',\n"
-                               "    save database first", refpath);
+        return GB_export_errorf("Quick save is missing master ARB file '%s',\n"
+                                "    save database first", refpath);
     }
     fclose(fmaster);
@@ -1235 +1235 @@
     sec_path = gb_overwriteName(path);
 
-    if ((out = fopen(sec_path, "w")) == NULL) return GB_export_error("ARBDB ERROR: Cannot save file to '%s'",sec_path);
+    if ((out = fopen(sec_path, "w")) == NULL) return GB_export_errorf("ARBDB ERROR: Cannot save file to '%s'",sec_path);
 
     slevel = Main->security_level;
@@ -1257 +1257 @@
     Main->transaction = translevel;
     erg |= fclose(out);
-    if (erg!=0) return GB_export_error("Cannot write to '%s'",sec_path); /* was: '%s%%'",path);*/
+    if (erg!=0) return GB_export_errorf("Cannot write to '%s'",sec_path); /* was: '%s%%'",path);*/
 
     if (GB_rename_file(sec_path,path)) return GB_get_error();
@@ -1329 +1329 @@
             lslash[0] = 0;
             if (!GB_is_directory(fullpath)) {
-                err = GB_export_error("Directory '%s' doesn't exist", fullpath);
+                err = GB_export_errorf("Directory '%s' doesn't exist", fullpath);
             }
             lslash[0] = '/';
@@ -1342 +1342 @@
         mode = GB_mode_of_link(path);
         if (mode >=0 && !(mode & S_IWUSR)){ /* no write access -> lookes like a master file */
-            return GB_export_error(
-                                   "Your selected file '%s' already exists and is write protected\n"
-                                   "    It looks like that your file is a master arb file which is\n"
-                                   "    used by some xxx.a?? quicksave databases\n"
-                                   "    If you want to save it nevertheless, delete it first !!!",
-                                   path);
+            return GB_export_errorf(
+                                    "Your selected file '%s' already exists and is write protected\n"
+                                    "    It looks like that your file is a master arb file which is\n"
+                                    "    used by some xxx.a?? quicksave databases\n"
+                                    "    If you want to save it nevertheless, delete it first !!!",
+                                    path);
         }
     }
     if ( strchr(flags,'n')){
         if (GB_time_of_file(path)){
-            return GB_export_error( "Your destination file '%s' already exists.\n"
+            return GB_export_errorf("Your destination file '%s' already exists.\n"
                                     "\tDelete it by hand first",path );
         }

trunk/ARBDB/adali.c

@@ -176 +176 @@
     if ( (error = GB_check_key(alignment_name)) ) return error;
     if (strncmp(alignment_name,"ali_",4)){
-        return GB_export_error("your alignment_name '%s' must start with 'ali_'",
-                               alignment_name);
+        return GB_export_errorf("your alignment_name '%s' must start with 'ali_'",
+                                alignment_name);
     }
     return 0;
@@ -269 +269 @@
     if (!result) {
         ad_assert(error);
-        GB_export_error("in GBT_create_alignment: %s", error);
+        GB_export_errorf("in GBT_create_alignment: %s", error);
     }
 #if defined(DEBUG)
@@ -716 +716 @@
     
     if (!gb_alignment_name) {
-        GB_export_error("alignment '%s' not found", aliname);
+        GB_export_errorf("alignment '%s' not found", aliname);
         return NULL;
     }
@@ -740 +740 @@
         GB_pop_my_security(gb_main);
     }
-    else error = GB_export_error("Alignment '%s' not found", aliname);
+    else error = GB_export_errorf("Alignment '%s' not found", aliname);
     return error;
 }
@@ -930 +930 @@
     if (error) {
         char *id = GEN_global_gene_identifier(gb_gene, gb_species);
-        error    = GB_export_error("Can't read sequence of '%s' (Reason: %s)", id, error);
+        error    = GB_export_errorf("Can't read sequence of '%s' (Reason: %s)", id, error);
         free(id);
         free(result);

trunk/ARBDB/adcomm.c

@@ -466 +466 @@
         gbd = (GBDATA *) buffer[2];
         if ( (error = gbcm_test_address((long *)gbd,GBTUM_MAGIC_NUMBER))) {
-            GB_export_error("address %p not valid 3712",gbd);
+            GB_export_errorf("address %p not valid 3712",gbd);
             GB_print_error();
             return GBCM_SERVER_FAULT;
@@ -579 +579 @@
         if (anz<0) continue;
         if (anz==0) {
-            GB_export_error("ARB_DB ERROR CLIENT TRANSACTION TIMEOUT, CLIENT DISCONNECTED (I waited %lu seconds)",timeout.tv_sec);
+            GB_export_errorf("ARB_DB ERROR CLIENT TRANSACTION TIMEOUT, CLIENT DISCONNECTED (I waited %lu seconds)",timeout.tv_sec);
             GB_print_error();
             gb_local->running_client_transaction = ARB_ABORT;
@@ -650 +650 @@
         if (anz<0) continue;
         if (anz==0) {
-            GB_export_error("ARB_DB ERROR CLIENT TRANSACTION TIMEOUT, CLIENT DISCONNECTED (I waited %lu seconds)",timeout.tv_sec);
+            GB_export_errorf("ARB_DB ERROR CLIENT TRANSACTION TIMEOUT, CLIENT DISCONNECTED (I waited %lu seconds)",timeout.tv_sec);
             GB_print_error();
             gb_local->running_client_transaction = ARB_ABORT;
@@ -680 +680 @@
     sin = sin;
     if ( (error = gbcm_test_address((long *)gbd,GBTUM_MAGIC_NUMBER)) ) {
-        GB_export_error("address %p not valid 4783",gbd);
+        GB_export_errorf("address %p not valid 4783",gbd);
         GB_print_error();
         if (error) return GBCM_SERVER_FAULT;
@@ -706 +706 @@
     sin = sin;
     if ( (error = gbcm_test_address((long *)gbd,GBTUM_MAGIC_NUMBER)) ) {
-        GB_export_error("address %p not valid 4356",gbd);
+        GB_export_errorf("address %p not valid 4356",gbd);
         GB_print_error();
         return GBCM_SERVER_FAULT;
@@ -830 +830 @@
 
     if ( (error = gbcm_test_address((long *) gbd, GBTUM_MAGIC_NUMBER)) ) {
-        GB_export_error("address %p not valid 8734", gbd);
+        GB_export_errorf("address %p not valid 8734", gbd);
         GB_print_error();
         return GBCM_SERVER_FAULT;
@@ -914 +914 @@
 
     if ( (error = gbcm_test_address((long *) gbd, GBTUM_MAGIC_NUMBER))) {
-        GB_export_error("address %p not valid 8734", gbd);
+        GB_export_errorf("address %p not valid 8734", gbd);
         GB_print_error();
         return GBCM_SERVER_FAULT;
@@ -1479 +1479 @@
     if (irror) {
         GB_ERROR error;
-        error = GB_export_error("GB_unfold (%s) read error",GB_read_key_pntr((GBDATA*)gbd));
+        error = GB_export_errorf("GB_unfold (%s) read error",GB_read_key_pntr((GBDATA*)gbd));
         return error;
     }
@@ -1497 +1497 @@
 {
     if (gbcm_write_two(GB_MAIN(gbd)->c_link->socket,GBCM_COMMAND_PUT_UPDATE,gbd->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     return 0;
@@ -1508 +1508 @@
     int socket = Main->c_link->socket;
     if (gbcm_write_two(socket,GBCM_COMMAND_PUT_UPDATE_END,gbd->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     gbcm_write_flush(socket);
@@ -1532 +1532 @@
     GBCONTAINER *father = GB_FATHER(gbd);
 
-    if (!father) return GB_export_error("internal error #2453:%s",GB_KEY(gbd));
+    if (!father) return GB_export_errorf("internal error #2453:%s",GB_KEY(gbd));
     if (gbcm_write_two(socket,GBCM_COMMAND_PUT_UPDATE_CREATE,father->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     buffer = (long *)GB_give_buffer(1014);
@@ -1547 +1547 @@
                         GBCM_COMMAND_PUT_UPDATE_DELETE,
                         gbd->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }else{
         return 0;
@@ -1559 +1559 @@
     GB_MAIN_TYPE *Main = GB_MAIN(gbd);
 
-    if (!GB_FATHER(gbd)) return GB_export_error("internal error #2453 %s",GB_KEY(gbd));
+    if (!GB_FATHER(gbd)) return GB_export_errorf("internal error #2453 %s",GB_KEY(gbd));
     if (gbcm_write_two(Main->c_link->socket,GBCM_COMMAND_PUT_UPDATE_UPDATE,gbd->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     buffer = (long *)GB_give_buffer(1016);
@@ -1612 +1612 @@
     buffer = (long *)GB_give_buffer(1026);
     if (gbcm_write_two(Main->c_link->socket,GBCM_COMMAND_BEGIN_TRANSACTION,Main->clock) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     if (gbcm_write_flush(socket)) {
@@ -1682 +1682 @@
 
     if (gbcm_write_two(socket,GBCM_COMMAND_INIT_TRANSACTION,Main->clock) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY((GBDATA*)gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY((GBDATA*)gbd));
     }
     gbcm_write_string(socket,Main->this_user->username);
@@ -1724 +1724 @@
 
     if (gbcm_write_two(socket,GBCM_COMMAND_COMMIT_TRANSACTION,gbd->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     if (gbcm_write_flush(socket)) {
@@ -1739 +1739 @@
     int socket = Main->c_link->socket;
     if (gbcm_write_two(socket,GBCM_COMMAND_ABORT_TRANSACTION,gbd->server_id) ) {
-        return GB_export_error("Cannot send '%s' to server",GB_KEY(gbd));
+        return GB_export_errorf("Cannot send '%s' to server",GB_KEY(gbd));
     }
     if (gbcm_write_flush(socket)) {
@@ -1951 +1951 @@
     result = gbcm_read_string(socket);
     gbcm_read_flush(socket);
-    if (result) GB_export_error("%s",result);
+    if (result) GB_export_errorf("%s",result);
     return result;
 }
@@ -2026 +2026 @@
         return 0;
     }
-    return GB_export_error("Too many users in this database: User '%s' ",user);
+    return GB_export_errorf("Too many users in this database: User '%s' ",user);
 }
 
@@ -2067 +2067 @@
         }
     }
-    return GB_export_error("User '%s' not logged in",user);
+    return GB_export_errorf("User '%s' not logged in",user);
 }
 

trunk/ARBDB/adcompr.c

@@ -1013 +1013 @@
                 }
                 else{
-                    error = GB_export_error("Internal Error: Cannot uncompress data of field '%s'",GB_read_key_pntr(gbd));
+                    error = GB_export_errorf("Internal Error: Cannot uncompress data of field '%s'",GB_read_key_pntr(gbd));
                 }
 

trunk/ARBDB/adindex.c

@@ -800 +800 @@
     GB_MAIN_TYPE *Main = GB_MAIN(gbd);
     if (memsize < _GBCMC_UNDOCOM_SET_MEM){
-        return  GB_export_error("Too less UNDO memory specified: should be more than %i",
+        return GB_export_errorf("Not enough UNDO memory specified: should be more than %i",
                                 _GBCMC_UNDOCOM_SET_MEM);
     }

trunk/ARBDB/aditem.c

@@ -48 +48 @@
     if (error) {
         gb_item = 0;
-        GB_export_error("Can't create %s '%s': %s", itemname, id, error);
+        GB_export_errorf("Can't create %s '%s': %s", itemname, id, error);
     }
 
@@ -92 +92 @@
         GBDATA     *gb_any   = GB_find(gb_item_data, id_field, down_2_level);
         const char *itemname = gb_any ? GB_read_key_pntr(GB_get_father(gb_any)) : "<item>";
-        GB_export_error("Could not find %s with %s '%s'", itemname, id_field, id_value);
+        GB_export_errorf("Could not find %s with %s '%s'", itemname, id_field, id_value);
     }
     return gb_found;

trunk/ARBDB/adlang1.c

@@ -212 +212 @@
             freeset(params, NULL);
             res = GBS_strclose(str);
-            err = GB_export_error("Unknown Parameter '%s' in command '%s'\n\tPARAMETERS:\n%s",argv[i].str,com,res);
+            err = GB_export_errorf("Unknown Parameter '%s' in command '%s'\n\tPARAMETERS:\n%s",argv[i].str,com,res);
             free(res);
             return err;
@@ -875 +875 @@
     else if (strcmp(args->command, "upper") == 0) mode = 1;
     else if (strcmp(args->command, "caps")  == 0) mode = 2;
-    else return GB_export_error("Unknown command '%s'", args->command);
+    else return GB_export_errorf("Unknown command '%s'", args->command);
 
     if (args->cparam!=0) return GBS_global_string("syntax: %s (no parameters)", args->command);
@@ -2297 +2297 @@
     if (error) {
         gb_assert(!seq);
-        GB_export_error("%s", error);
+        GB_export_error(error);
     }
 

trunk/ARBDB/adlink.c

@@ -17 +17 @@
     s = strchr(link,':');
     if (!s){
-        GB_export_error("Your link '%s' does not contain a ':' character",link);
+        GB_export_errorf("Your link '%s' does not contain a ':' character",link);
         return 0;
     }
@@ -25 +25 @@
     *s = c;
     if (!lf){
-        GB_export_error("Your link tag '%s' is unknown to the system",link);
+        GB_export_errorf("Your link tag '%s' is unknown to the system",link);
         return 0;
     }

trunk/ARBDB/admap.c

@@ -677 +677 @@
  error:
 
-    GB_export_error("Error while saving FastLoad-File '%s'", opath);
+    GB_export_errorf("Error while saving FastLoad-File '%s'", opath);
     GB_unlink_or_warn(opath, NULL);
 

trunk/ARBDB/admatch.c

@@ -749 +749 @@
             *(bar++) = 0;
         } else {
-            GB_export_error("SRT ERROR: no '=' found in command '%s' (position > %zi)", icommand, doppelpunkt-command+1);
+            GB_export_errorf("SRT ERROR: no '=' found in command '%s' (position > %zi)", icommand, doppelpunkt-command+1);
             free(command);
             free(in);
@@ -848 +848 @@
                 free(command);
                 free(in);
-                GB_export_error("%s",error);
+                GB_export_error(error);
                 return 0;
             }

trunk/ARBDB/adname.c

@@ -90 +90 @@
 
         if (gb_found_species && gb_species != gb_found_species) {
-            return GB_export_error("A species named '%s' already exists.",newname);
+            return GB_export_errorf("A species named '%s' already exists.",newname);
         }
     }
 
     if (!gb_species) {
-        return GB_export_error("Expected that a species named '%s' exists (maybe there are duplicate species, database might be corrupt)",oldname);
+        return GB_export_errorf("Expected that a species named '%s' exists (maybe there are duplicate species, database might be corrupt)",oldname);
     }
 

trunk/ARBDB/adquery.c

@@ -441 +441 @@
             GB_TYPES oldType = GB_TYPE(gbsp);
             if (create != oldType) { /* type mismatch */
-                GB_export_error("Inconsistent type for field '%s' (existing=%i, expected=%i)", str, oldType, create);
+                GB_export_errorf("Inconsistent type for field '%s' (existing=%i, expected=%i)", str, oldType, create);
                 return NULL;
             }
@@ -481 +481 @@
             if (seperator == '-') {
                 if ((*s2)  != '>'){
-                    GB_export_error("Invalid key for gb_search '%s'",str);
+                    GB_export_errorf("Invalid key for gb_search '%s'",str);
                     GB_print_error();
                     return NULL;
@@ -554 +554 @@
     long type = GB_TYPE(gbd);
     if (type != expected_type) {
-        GB_export_error("Field '%s' has wrong type (found=%li, expected=%li)", fieldname, type, expected_type);
+        GB_export_errorf("Field '%s' has wrong type (found=%li, expected=%li)", fieldname, type, expected_type);
         gbd = 0;
     }
@@ -946 +946 @@
                     const char *hp = gbs_search_second_x(s1+1);
                     if (!hp){
-                        GB_export_error("unbalanced '\"' in '%s'",commands);
+                        GB_export_errorf("unbalanced '\"' in '%s'",commands);
                         return NULL;
                     }
@@ -1163 +1163 @@
     }
 
-    GB_export_error("Command '%s' failed:\nReason: %s", commands, error);
+    GB_export_errorf("Command '%s' failed:\nReason: %s", commands, error);
     return NULL;
 }

trunk/ARBDB/adseqcompr.c

@@ -416 +416 @@
         int leafcount = g_b_count_leafs(tree);
         if (!leafcount) {
-            error = GB_export_error("Tree contains no sequences with data in '%s'", ali_name);
+            error = GB_export_errorf("Tree contains no sequences with data in '%s'", ali_name);
         }
         else {
@@ -726 +726 @@
     ctree = (GB_CTREE *)GBT_read_tree(gb_main,(char *)tree_name,-sizeof(GB_CTREE));
     if (!ctree) {
-        error = GB_export_error("Tree %s not found in database",tree_name);
+        error = GB_export_errorf("Tree %s not found in database",tree_name);
     }
     else {

trunk/ARBDB/adsocket.c

@@ -358 +358 @@
                 return "Could not open socket on Server";
             }
-            if (chmod(mach_name[0],0777)) return GB_export_error("Cannot change mode of socket '%s'",mach_name[0]);
+            if (chmod(mach_name[0],0777)) return GB_export_errorf("Cannot change mode of socket '%s'",mach_name[0]);
         }
         *unix_name = mach_name[0];
@@ -646 +646 @@
 GB_ERROR GB_symlink(const char *name1, const char *name2){  /* name1 is the existing file !!! */
     if (symlink(name1,name2)<0){
-        return GB_export_error("Cannot create symlink '%s' to file '%s'",name2,name1);
+        return GB_export_errorf("Cannot create symlink '%s' to file '%s'",name2,name1);
     }
     return 0;
@@ -653 +653 @@
 GB_ERROR GB_set_mode_of_file(const char *path,long mode)
 {
-    if (chmod(path, (int)mode)) return GB_export_error("Cannot change mode of '%s'",path);
+    if (chmod(path, (int)mode)) return GB_export_errorf("Cannot change mode of '%s'",path);
     return 0;
 }
@@ -735 +735 @@
     }
     if (buffer == MAP_FAILED){
-        GB_export_error("GB_map_file: Error Out of Memory: mmap failes (errno: %i)", errno);
+        GB_export_errorf("GB_map_file: Error Out of Memory: mmap failes (errno: %i)", errno);
         return NULL;
     }
@@ -746 +746 @@
     in = fopen(path,"r");
     if (!in) {
-        GB_export_error("GB_map_file: sorry file '%s' not readable",path);
+        GB_export_errorf("GB_map_file: sorry file '%s' not readable",path);
         return NULL;
     }
@@ -1245 +1245 @@
     }
     else if (strlen(anypath) >= PATH_MAX) {
-        GB_export_error("Path too long (> %i chars)", PATH_MAX-1);
+        GB_export_errorf("Path too long (> %i chars)", PATH_MAX-1);
     }
     else {

trunk/ARBDB/adstring.c

@@ -56 +56 @@
     dirp = opendir(fulldir);
     if (!dirp){
-        GB_ERROR error = GB_export_error("Directory %s of file %s.arb not readable",fulldir,file);
+        GB_ERROR error = GB_export_errorf("Directory %s of file %s.arb not readable",fulldir,file);
         free(path);
         return error;
@@ -211 +211 @@
  * 
  * GB_export_error() shall only export, not return the error message.
- * if only used for formatting GBS_global_string shall be used.
+ * if only used for formatting GBS_global_string shall be used
+ * (most cases where GB_export_errorf is used are candidates for this.
+ *  GB_export_error was generally misused for this, before
+ *  GBS_global_string was added!)
  *
  * GB_export_IO_error() shall not export and be renamed into GB_IO_error()
@@ -224 +227 @@
 static char *GB_error_buffer = 0;
 
-GB_ERROR GB_export_error(const char *templat, ...) {
-    /* goes to header: __ATTR__FORMAT(1) */
+GB_ERROR GB_export_error(const char *error) { // just a temp hack around format-warnings
+    return GB_export_errorf("%s", error);
+}
+
+GB_ERROR GB_export_errorf(const char *templat, ...) {
+    /* goes to header: __ATTR__FORMAT(1) __ATTR__DEPRECATED */
 
     char     buffer[GBS_GLOBAL_STRING_SIZE];
-    char    *p  = buffer;
+    char    *p = buffer;
     va_list  parg;
+    
     memset(buffer,0,1000);
+
 #if defined(DEVEL_RALF)
-#warning dont prepend error here    
+#warning dont prepend error here
 #endif /* DEVEL_RALF */
-    sprintf (buffer,"ARB ERROR: ");
-    p          += strlen(p);
+
+    p += sprintf(buffer,"ARB ERROR: ");
     va_start(parg,templat);
 
@@ -568 +577 @@
     if (!key || key[0] == 0) return GB_export_error("Empty key is not allowed");
     len = strlen(key);
-    if (len>GB_KEY_LEN_MAX) return GB_export_error("Invalid key '%s': too long",key);
-    if (len < GB_KEY_LEN_MIN) return GB_export_error("Invalid key '%s': too short",key);
+    if (len>GB_KEY_LEN_MAX) return GB_export_errorf("Invalid key '%s': too long",key);
+    if (len < GB_KEY_LEN_MIN) return GB_export_errorf("Invalid key '%s': too short",key);
 
     for (i = 0; key[i]; ++i) {
@@ -577 +586 @@
         if ( (c>='0') && (c<='9')) continue;
         if ( (c=='_') ) continue;
-        return GB_export_error("Invalid character '%c' in '%s'; allowed: a-z A-Z 0-9 '_' ", c, key);
+        return GB_export_errorf("Invalid character '%c' in '%s'; allowed: a-z A-Z 0-9 '_' ", c, key);
     }
 
@@ -589 +598 @@
     if (!key || key[0] == 0) return GB_export_error("Empty key is not allowed");
     len = strlen(key);
-    if (len>GB_KEY_LEN_MAX) return GB_export_error("Invalid key '%s': too long",key);
-    if (len < 1) return GB_export_error("Invalid key '%s': too short",key); // here it differs from GB_check_key
+    if (len>GB_KEY_LEN_MAX) return GB_export_errorf("Invalid key '%s': too long",key);
+    if (len < 1) return GB_export_errorf("Invalid key '%s': too short",key); // here it differs from GB_check_key
 
     for (i = 0; key[i]; ++i) {
@@ -598 +607 @@
         if ( (c>='0') && (c<='9')) continue;
         if ( (c=='_') ) continue;
-        return GB_export_error("Invalid character '%c' in '%s'; allowed: a-z A-Z 0-9 '_' ", c, key);
+        return GB_export_errorf("Invalid character '%c' in '%s'; allowed: a-z A-Z 0-9 '_' ", c, key);
     }
 
@@ -631 +640 @@
                 if (c == '-') {
                     if (key_end[1] != '>') {
-                        err = GB_export_error("'>' expected after '-' in '%s'", key);
+                        err = GB_export_errorf("'>' expected after '-' in '%s'", key);
                     }
                     start = key_end+2;
@@ -1086 +1095 @@
             }
 
-            if (!names) GB_export_error("can't read directory '%s'", fulldir);
+            if (!names) GB_export_errorf("can't read directory '%s'", fulldir);
         }
     }

trunk/ARBDB/adtables.c

@@ -41 +41 @@
     sep = strchr(link,':');
     if (!sep){
-        GB_export_error("Link '%s' is missing second ':' tag", link);
+        GB_export_errorf("Link '%s' is missing second ':' tag", link);
         return NULL;
     }
@@ -50 +50 @@
 
     if (!gb_table){
-        GB_export_error("Table '%s' does not exist",link);
+        GB_export_errorf("Table '%s' does not exist",link);
         return NULL;
     }
@@ -202 +202 @@
     GB_TYPES type = GBT_get_type_of_table_entry_field(gb_table,fieldname);
     if (type == GB_NONE){
-        return GB_export_error("There is no field description '%s' for your table", fieldname);
+        return GB_export_errorf("There is no field description '%s' for your table", fieldname);
     }
     gb_entry_field = GB_search(gb_entry,"fieldname",type);

trunk/ARBDB/adtools.c

@@ -65 +65 @@
     if (strchr(name,':')) return 0;
     in = fopen(name,"r");
-    if (!in) return GB_export_error("Cannot find file '%s'",name);
+    if (!in) return GB_export_errorf("Cannot find file '%s'",name);
     i = gb_read_in_long(in, 0);
     if ( (i== 0x56430176) || (i == GBTUM_MAGIC_NUMBER) || (i == GBTUM_MAGIC_REVERSED)) {
@@ -79 +79 @@
 
 
-    return GB_export_error("'%s' is not an arb file",name);
+    return GB_export_errorf("'%s' is not an arb file",name);
 }
 

trunk/ARBDB/adtree.c

@@ -625 +625 @@
 
     gb_assert(error);
-    GB_export_error("Couldn't read tree '%s' (Reason: %s)", tree_name, error);
+    GB_export_errorf("Couldn't read tree '%s' (Reason: %s)", tree_name, error);
     return NULL;
 }
@@ -801 +801 @@
     
     if (!gb_tree) {
-        GB_export_error("tree '%s' not found",tree_name);
+        GB_export_errorf("tree '%s' not found",tree_name);
     }
     else {
         GBDATA *gb_nnodes = GB_entry(gb_tree,"nnodes");
         if (!gb_nnodes) {
-            GB_export_error("nnodes not found in tree '%s'",tree_name);
+            GB_export_errorf("nnodes not found in tree '%s'",tree_name);
         }
         else {
@@ -842 +842 @@
     if ( (error = GB_check_key(tree_name)) ) return error;
     if (strncmp(tree_name,"tree_",5)){
-        return GB_export_error("your treename '%s' does not begin with 'tree_'",tree_name);
+        return GB_export_errorf("your treename '%s' does not begin with 'tree_'",tree_name);
     }
     return 0;

trunk/ARBDB/arbdb.c

@@ -984 +984 @@
         case GB_FLOAT:  return GB_write_float(gbd,GB_atof(val));
         case GB_BITS:   return GB_write_bits(gbd,val,strlen(val),"0");
-        default:    return GB_export_error("Error: You cannot use GB_write_as_string on this type of entry (%s)",GB_read_key_pntr(gbd));
+        default:    return GB_export_errorf("Error: You cannot use GB_write_as_string on this type of entry (%s)",GB_read_key_pntr(gbd));
     }
 }
@@ -1012 +1012 @@
 GB_ERROR gb_security_error(GBDATA *gbd){
     GB_MAIN_TYPE *Main = GB_MAIN(gbd);
-    const char *error  = GB_export_error("Protection: Attempt to change a level-%i-'%s'-entry, \n"
-                                         "but your current security level is only %i",
-                                         GB_GET_SECURITY_WRITE(gbd),
-                                         GB_read_key_pntr(gbd),
-                                         Main->security_level);
+    const char *error  = GB_export_errorf("Protection: Attempt to change a level-%i-'%s'-entry, \n"
+                                          "but your current security level is only %i",
+                                          GB_GET_SECURITY_WRITE(gbd),
+                                          GB_read_key_pntr(gbd),
+                                          Main->security_level);
 
 #if defined(DEBUG)
@@ -1297 +1297 @@
     GB_TEST_TRANSACTION(father);
     if ( GB_TYPE(father)!=GB_DB) {
-        GB_export_error("GB_create: father (%s) is not of GB_DB type (%i) (creating '%s')",
-                        GB_read_key_pntr(father),GB_TYPE(father),key);
+        GB_export_errorf("GB_create: father (%s) is not of GB_DB type (%i) (creating '%s')",
+                         GB_read_key_pntr(father),GB_TYPE(father),key);
         return NULL;
     };
@@ -1330 +1330 @@
     GB_TEST_TRANSACTION(father);
     if ( GB_TYPE(father)!=GB_DB) {
-        GB_export_error("GB_create: father (%s) is not of GB_DB type (%i) (creating '%s')",
-                        GB_read_key_pntr(father),GB_TYPE(father),key);
+        GB_export_errorf("GB_create: father (%s) is not of GB_DB type (%i) (creating '%s')",
+                         GB_read_key_pntr(father),GB_TYPE(father),key);
         return NULL;
     };
@@ -1349 +1349 @@
     GB_TEST_TRANSACTION(source);
     if (GB_GET_SECURITY_DELETE(source)>GB_MAIN(source)->security_level) {
-        return GB_export_error("Security error in GB_delete: %s",GB_read_key_pntr(source));
+        return GB_export_errorf("Security error in GB_delete: %s",GB_read_key_pntr(source));
     }
 
@@ -1412 +1412 @@
     if (GB_TYPE(dest) != type)
     {
-        return GB_export_error("incompatible types in GB_copy (source %s:%u != %s:%u",
-                               GB_read_key_pntr(source), type, GB_read_key_pntr(dest), GB_TYPE(dest));
+        return GB_export_errorf("incompatible types in GB_copy (source %s:%u != %s:%u",
+                                GB_read_key_pntr(source), type, GB_read_key_pntr(dest), GB_TYPE(dest));
     }
 
@@ -1451 +1451 @@
             if (GB_TYPE(destc) != GB_DB)
             {
-                GB_ERROR err = GB_export_error("GB_COPY Type conflict %s:%i != %s:%i",
-                                               GB_read_key_pntr(dest), GB_TYPE(dest), GB_read_key_pntr(source), GB_DB);
+                GB_ERROR err = GB_export_errorf("GB_COPY Type conflict %s:%i != %s:%i",
+                                                GB_read_key_pntr(dest), GB_TYPE(dest), GB_read_key_pntr(source), GB_DB);
                 GB_internal_error(err);
                 return err;
@@ -1626 +1626 @@
     GB_TEST_TRANSACTION(gbd);
     if (GB_GET_SECURITY_DELETE(gbd)>GB_MAIN(gbd)->security_level)
-        return GB_export_error("Security error in GB_set_temporary: %s",GB_read_key_pntr(gbd));
+        return GB_export_errorf("Security error in GB_set_temporary: %s",GB_read_key_pntr(gbd));
     gbd->flags.temporary = 1;
     gb_touch_entry(gbd,gb_changed);
@@ -1731 +1731 @@
     gbd                = (GBDATA *)Main->data;
     if (Main->transaction>0) {
-        error = GB_export_error("GB_begin_transaction called %i !!!",
-                                Main->transaction);
+        error = GB_export_errorf("GB_begin_transaction called %i !!!",
+                                 Main->transaction);
         GB_internal_error(error);
         return GB_push_transaction(gbd);
@@ -2275 +2275 @@
     }
     if (GB_TYPE(gbd) != GB_DB) {
-        GB_ERROR error=GB_export_error("You cannot release non container (%s)",
-                                       GB_read_key_pntr(gbd));
+        GB_ERROR error = GB_export_errorf("You cannot release non container (%s)",
+                                          GB_read_key_pntr(gbd));
         GB_internal_error(error);
         return error;
@@ -2336 +2336 @@
 
     if (GB_read_clients(gb_main)>0)
-        return GB_export_error("There are %li clients (editors, tree programms) connected to this server,\n"
-                               "please close clients and rerun operation",
-                               GB_read_clients(gb_main));
+        return GB_export_errorf("There are %li clients (editors, tree programms) connected to this server,\n"
+                                "please close clients and rerun operation",
+                                GB_read_clients(gb_main));
 
     if (listsize <=0) return 0;
@@ -2427 +2427 @@
     GBCONTAINER *gbc = (GBCONTAINER *)gbd;
     if (GB_TYPE(gbc) != GB_DB) {
-        GB_ERROR error = GB_export_error("GB_write_usr_private: not a container (%s)",GB_read_key_pntr(gbd));
+        GB_ERROR error = GB_export_errorf("GB_write_usr_private: not a container (%s)",GB_read_key_pntr(gbd));
         GB_internal_error(error);
         return 0;
@@ -2437 +2437 @@
     GBCONTAINER *gbc = (GBCONTAINER *)gbd;
     if (GB_TYPE(gbc) != GB_DB) {
-        GB_ERROR error = GB_export_error("GB_write_usr_private: not a container (%s)",GB_read_key_pntr(gbd));
+        GB_ERROR error = GB_export_errorf("GB_write_usr_private: not a container (%s)",GB_read_key_pntr(gbd));
         GB_internal_error(error);
         return 0;

trunk/AWT/AWT_csp.cxx

@@ -82 +82 @@
     GB_ERROR error = 0;
     if (alignment_length <= 1)
-        return GB_export_error( "Unknown Alignment Size: Name '%s'\n"
+        return GB_export_errorf("Unknown Alignment Size: Name '%s'\n"
                                 "   Select a Valid Alignment",alignment_name);
     if (filter && filter->filter_len != alignment_length)

trunk/AWT/AWT_input_mask.cxx

@@ -144 +144 @@
 GB_ERROR awt_input_mask_id_list::add(const string& name, awt_mask_item *item) {
     awt_mask_item *existing = lookup(name);
-    if (existing) return GB_export_error("ID '%s' already exists", name.c_str());
+    if (existing) return GB_export_errorf("ID '%s' already exists", name.c_str());
 
     id[name] = item;
@@ -150 +150 @@
 }
 GB_ERROR awt_input_mask_id_list::remove(const string& name) {
-    if (!lookup(name)) return GB_export_error("ID '%s' does not exist", name.c_str());
+    if (!lookup(name)) return GB_export_errorf("ID '%s' does not exist", name.c_str());
     id.erase(name);
     return 0;
@@ -168 +168 @@
     GB_ERROR error = 0;
     if (has_name()) {
-        error = GB_export_error("Element already has name (%s)", get_name().c_str());
+        error = GB_export_errorf("Element already has name (%s)", get_name().c_str());
     }
     else {
@@ -1664 +1664 @@
 
                                     if ((cmd == CMD_GLOBAL && local_exists) || (cmd == CMD_LOCAL && global_exists)) {
-                                        error = GB_export_error("ID '%s' already declared as %s ID (rename your local id)",
-                                                                id.c_str(), cmd == CMD_LOCAL ? "global" : "local");
+                                        error = GB_export_errorf("ID '%s' already declared as %s ID (rename your local id)",
+                                                                 id.c_str(), cmd == CMD_LOCAL ? "global" : "local");
                                     }
                                     else if (cmd == CMD_LOCAL && local_exists) {
-                                        error = GB_export_error("ID '%s' declared twice", id.c_str());
+                                        error = GB_export_errorf("ID '%s' declared twice", id.c_str());
                                     }
 
@@ -1899 +1899 @@
                 for (map<string, size_t>::const_iterator r = referenced_ids.begin(); r != referenced_ids.end(); ++r) {
                     if (declared_ids.find(r->first) == declared_ids.end()) {
-                        error = GB_export_error("ID '%s' used in line #%zu was not declared", r->first.c_str(), r->second);
+                        error = GB_export_errorf("ID '%s' used in line #%zu was not declared", r->first.c_str(), r->second);
                         aw_message(error);
                     }

trunk/AWT/AWT_nds.cxx

@@ -362 +362 @@
                 }
                 else {
-                    error = GB_export_error("Expected entry '%s' in saved config", inherit_key);
+                    error = GB_export_errorf("Expected entry '%s' in saved config", inherit_key);
                 }
             }
@@ -398 +398 @@
                 }
                 else {
-                    error = GB_export_error("Expected entry '%s' in saved config", flag1_key);
+                    error = GB_export_errorf("Expected entry '%s' in saved config", flag1_key);
                 }
             }

trunk/AWT/AWT_query_and_functions.cxx

@@ -2333 +2333 @@
                             else {
                                 char *name = GBT_read_string(gb_item,"name");
-                                error = GB_export_error("Field '%s' of %s '%s' has incombatible type", key, cbs->selector->item_name, name);
+                                error = GB_export_errorf("Field '%s' of %s '%s' has incombatible type", key, cbs->selector->item_name, name);
                                 free(name);
                             }

trunk/AWT/AWT_seq_colors.cxx

@@ -200 +200 @@
             char *val = GBT_read_string(gb_def,buf);
             if (strlen(val) != 2 || val[1] >'9' || val[1] < '0'){
-                aw_message(GB_export_error("Error in Color Lookup Table: '%s' is not of type X#",val));
+                aw_message(GB_export_errorf("Error in Color Lookup Table: '%s' is not of type X#",val));
                 delete val;
                 delete sc;

trunk/AWT/AWT_tree.cxx

@@ -1137 +1137 @@
     else if (new_group->is_leaf) {
         if (new_group->name) {
-            error = GB_export_error("'%s' is not a valid target for group information of '%s'.", new_group->name, name);
+            error = GB_export_errorf("'%s' is not a valid target for group information of '%s'.", new_group->name, name);
         }
         else if (new_group->gb_node) {

trunk/AWT/AWT_www.cxx

@@ -111 +111 @@
 
     if (!gb_species){
-        error = GB_export_error("Cannot find species '%s'",selected_species);
+        error = GB_export_errorf("Cannot find species '%s'",selected_species);
     }else{
         error = awt_openURL_by_gbd(aw_root,gb_main, gb_species, selected_species);

trunk/AWT/awt_input_mask_internal.hxx

@@ -125 +125 @@
 
     GB_ERROR add_local_id(const std::string& name, awt_mask_item *handler) {
-        if (has_global_id(name)) return GB_export_error("ID '%s' already defined as GLOBAL", name.c_str());
+        if (has_global_id(name)) return GB_export_errorf("ID '%s' already defined as GLOBAL", name.c_str());
         return ids.add(name, handler);
     }
 
     GB_ERROR add_global_id(const std::string& name, awt_mask_item *handler) {
-        if (has_local_id(name)) return GB_export_error("ID '%s' already defined as LOCAL", name.c_str());
+        if (has_local_id(name)) return GB_export_errorf("ID '%s' already defined as LOCAL", name.c_str());
         return global_ids.add(name, handler);
     }
@@ -147 +147 @@
             found             = ids.lookup(name);
             if (!found) found = global_ids.lookup(name);
-            if (!found) error = GB_export_error("No item '%s' declared", name.c_str());
+            if (!found) error = GB_export_errorf("No item '%s' declared", name.c_str());
         }
         return found;

trunk/AWTI/AWTI_import.cxx

@@ -789 +789 @@
                 char *file = 0;
                 if (awtcig.current_file[0]) file = awtcig.current_file[0];
-                GB_ERROR msg = GB_export_error("A database entry in file '%s' is longer than %i lines.\n"
-                                               "    This might be the result of a wrong input format\n"
-                                               "    or a long comment in a sequence\n",file,line);
+                GB_ERROR msg = GB_export_errorf("A database entry in file '%s' is longer than %i lines.\n"
+                                                "    This might be the result of a wrong input format\n"
+                                                "    or a long comment in a sequence\n",file,line);
 
                 switch (aw_question(msg,"Continue Reading,Continue Reading (Never ask again),Abort"))  {
@@ -889 +889 @@
             if (!p) break;
         }
-        return GB_export_error("No Start of Sequence found (%i lines read)", max_line);
+        return GB_export_errorf("No Start of Sequence found (%i lines read)", max_line);
 
     read_sequence:

trunk/DIST/DI_matr.cxx

@@ -314 +314 @@
                 if (!gb_species) {
                     if (show_warnings) {
-                        aw_message(GB_export_error("Species '%s' found in tree '%s' but NOT in database.",
-                                                   species_in_sort_tree[i], sort_tree_name));
+                        aw_message(GB_export_errorf("Species '%s' found in tree '%s' but NOT in database.",
+                                                    species_in_sort_tree[i], sort_tree_name));
                     }
                     unknown_species_in_tree++;
@@ -355 +355 @@
 
     if (unknown_species_in_tree && show_warnings) {
-        aw_message(GB_export_error("We found %i species in tree '%s' which are not in database.\n"
-                                   "This does not affect the current calculation, but you should think about it.",
-                                   unknown_species_in_tree, sort_tree_name));
+        aw_message(GB_export_errorf("We found %i species in tree '%s' which are not in database.\n"
+                                    "This does not affect the current calculation, but you should think about it.",
+                                    unknown_species_in_tree, sort_tree_name));
     }
 

trunk/DIST/DI_mldist.cxx

@@ -266 +266 @@
                         tt -= slope / curv;
                         if (tt > 10000.0) {
-                            aw_message(GB_export_error("INFINITE DISTANCE BETWEEN SPECIES %ld AND %ld; -1.0 WAS WRITTEN\n", i, j));
+                            aw_message(GB_export_errorf("INFINITE DISTANCE BETWEEN SPECIES %ld AND %ld; -1.0 WAS WRITTEN\n", i, j));
                             tt = -1.0 / fracchange;
                             break;

trunk/DIST/DI_protdist.cxx

@@ -715 +715 @@
                             tt -= slope / curv;
                             if (tt > 10000.0) {
-                                aw_message(GB_export_error("INFINITE DISTANCE BETWEEN SPECIES %ld AND %ld; -1.0 WAS WRITTEN\n", i, j));
+                                aw_message(GB_export_errorf("INFINITE DISTANCE BETWEEN SPECIES %ld AND %ld; -1.0 WAS WRITTEN\n", i, j));
                                 tt = -1.0 / fracchange;
                                 break;
@@ -761 +761 @@
                                 double drel = 1.0 - rel - 0.2 * rel * rel;
                                 if (drel < 0.0) {
-                                    aw_message(GB_export_error("DISTANCE BETWEEN SEQUENCES %3ld AND %3ld IS TOO LARGE FOR KIMURA FORMULA", i, j));
+                                    aw_message(GB_export_errorf("DISTANCE BETWEEN SEQUENCES %3ld AND %3ld IS TOO LARGE FOR KIMURA FORMULA", i, j));
                                     tt = -1.0;
                                 }else{

trunk/EDIT/edit.cxx

@@ -445 +445 @@
             default:
                 if (does_species_exists(spname)) {
-                    if (do_what == 1) error = GB_export_error("Species %s already exists",spname);
+                    if (do_what == 1) error = GB_export_errorf("Species %s already exists",spname);
                 }else{
-                    if (do_what == 0) error = GB_export_error("Cannot find species %s",spname);
+                    if (do_what == 0) error = GB_export_errorf("Cannot find species %s",spname);
                 }
         }

trunk/EDIT4/ED4_ProteinViewer.cxx

@@ -604 +604 @@
                 startPos4Translation = atoi(GB_read_char_pntr(gb_codonStart))-1;
                 if (startPos4Translation<0 || startPos4Translation>2) {
-                    error = GB_export_error("'%s' has invalid codon_start entry %i (allowed: 1..3)",
-                                            speciesName, startPos4Translation+1);
+                    error = GB_export_errorf("'%s' has invalid codon_start entry %i (allowed: 1..3)",
+                                             speciesName, startPos4Translation+1);
                     break;
                 }

trunk/EDIT4/ED4_no_class.cxx

@@ -1254 +1254 @@
         }
         else if (!foundField) {
-            error = GB_export_error("Field not found: '%s'", field_name);
+            error = GB_export_errorf("Field not found: '%s'", field_name);
         }
     }
@@ -1787 +1787 @@
     }
     else {
-        error = GB_export_error("Can't find alignment '%s'", ali);
+        error = GB_export_errorf("Can't find alignment '%s'", ali);
     }
     free(consensus);

trunk/EDIT4/ED4_protein_2nd_structure.cxx

@@ -1003 +1003 @@
         if (protstruct_len) protstruct_len = 0;
         if (aw_root->awar(PFOLD_AWAR_ENABLE)->read_int()) {
-            error = GB_export_error( "SAI \"%s\" does not exist.\nDisabled protein structure display!", SAI_name );
+            error = GB_export_errorf( "SAI \"%s\" does not exist.\nDisabled protein structure display!", SAI_name );
             aw_root->awar(PFOLD_AWAR_ENABLE)->write_int(0);
         }

trunk/GENOM/EXP_interface.cxx

@@ -295 +295 @@
 
             if (gb_dest) {
-                error  = GB_export_error("Experiment '%s' already exists", dest);
+                error  = GB_export_errorf("Experiment '%s' already exists", dest);
             }
             else {
@@ -326 +326 @@
 
                 if (!gb_source) error   = "Please select an experiment";
-                else if (gb_dest) error = GB_export_error("Experiment '%s' already exists", dest);
+                else if (gb_dest) error = GB_export_errorf("Experiment '%s' already exists", dest);
                 else {
                     GBDATA *gb_name     = GB_search(gb_source, "name", GB_STRING);
@@ -361 +361 @@
 
             if (!gb_source) error   = "Please select a experiment";
-            else if (gb_dest) error = GB_export_error("Experiment '%s' already exists", dest);
+            else if (gb_dest) error = GB_export_errorf("Experiment '%s' already exists", dest);
             else {
                 gb_dest             = GB_create_container(gb_experiment_data,"experiment");

trunk/GENOM/GEN_interface.cxx

@@ -359 +359 @@
 
                 if (!gb_source) error   = "Please select a gene first";
-                else if (gb_dest) error = GB_export_error("Gene '%s' already exists", dest);
+                else if (gb_dest) error = GB_export_errorf("Gene '%s' already exists", dest);
                 else {
                     GBDATA *gb_name = GB_search(gb_source, "name", GB_STRING);
@@ -417 +417 @@
 
             if (!gb_source) error   = "Please select a gene";
-            else if (gb_dest) error = GB_export_error("Gene '%s' already exists", dest);
+            else if (gb_dest) error = GB_export_errorf("Gene '%s' already exists", dest);
             else {
                 gb_dest             = GB_create_container(gb_gene_data,"gene");

trunk/GENOM/GEN_map.cxx

@@ -684 +684 @@
     else { // key exists
         if (GB_read_type(gbd) != GB_STRING) { // test correct key type
-            error = GB_export_error("field '%s' exists and has wrong type", key);
+            error = GB_export_errorf("field '%s' exists and has wrong type", key);
         }
     }
@@ -871 +871 @@
                     gen_assert(short_name);
                     gb_exist_geneSpec = GBT_find_or_create_species(GLOBAL_gb_main, short_name);
-                    if (!gb_exist_geneSpec) error = GB_export_error("Failed to create pseudo-species '%s'", short_name);
+                    if (!gb_exist_geneSpec) error = GB_export_errorf("Failed to create pseudo-species '%s'", short_name);
                     else eg2ps->existing.add_name(short_name);
                 }

trunk/MERGE/MG_gene_species.cxx

@@ -272 +272 @@
         GBDATA         *gb_species = GBT_find_species(GLOBAL_gb_merge, curr_species);
 
-        if (!gb_species)                                    error = GB_export_error("No such species: '%s'", curr_species);
+        if (!gb_species)                                    error = GB_export_errorf("No such species: '%s'", curr_species);
         else if (!GEN_is_pseudo_gene_species(gb_species))   error = "Selected species is no gene-species";
         else {

trunk/MERGE/MG_preserves.cxx

@@ -125 +125 @@
         }
         default:
-            GB_export_error("Data type %s is not supported", GB_get_type_name(gb_data));
+            GB_export_errorf("Data type %s is not supported", GB_get_type_name(gb_data));
             break;
     }

trunk/MERGE/MG_species.cxx

@@ -1001 +1001 @@
         switch (d) {
             case 0:
-                error = GB_export_error("Cannot find a target alignment with a type of '%s'\n"
-                                        "You should create one first or select a different alignment type\n"
-                                        "during sequence import",type);
+                error = GB_export_errorf("Cannot find a target alignment with a type of '%s'\n"
+                                         "You should create one first or select a different alignment type\n"
+                                         "during sequence import",type);
                 break;
             case 1:

trunk/NTREE/AP_consensus.cxx

@@ -609 +609 @@
 
     long maxalignlen = GBT_get_alignment_len(GLOBAL_gb_main,align);
-    if (maxalignlen <= 0) error = GB_export_error("alignment '%s' doesn't exist", align);
+    if (maxalignlen <= 0) error = GB_export_errorf("alignment '%s' doesn't exist", align);
 
     if (!error) {

trunk/NTREE/AP_csp_2_gnuplot.cxx

@@ -41 +41 @@
 
     const char *lslash = strrchr(fname, '/');
-    if (!lslash) return GB_export_error("'%s' has to contain a '/'", fname);
+    if (!lslash) return GB_export_errorf("'%s' has to contain a '/'", fname);
 
     char *dir         = strdup(fname);
@@ -270 +270 @@
             if (!error) {
                 out = fopen(fname,"w");
-                if (!out) error = GB_export_error("Cannot write to file '%s'",fname);
+                if (!out) error = GB_export_errorf("Cannot write to file '%s'",fname);
             }
 

trunk/NTREE/NT_concatenate.cxx

@@ -666 +666 @@
                     if (!error) id += GBS_checksum(seq_data,1,".-");  //creating checksum of the each aligned sequence to generate new accession number
                 }
-                if (error) error = GB_export_error("Can't create alignment '%s'", ali_names[no_of_alignments]);
+                if (error) error = GB_export_errorf("Can't create alignment '%s'", ali_names[no_of_alignments]);
             }
         }

trunk/PARSIMONY/AP_tree_edge.cxx

@@ -579 +579 @@
         int diff = ne[i] - old[i];
         if (diff > 1 || diff < -1){
-            GB_export_error("shit shit shit, diff by nni at one position not in [-1,1]: %i:%i - %i",diff,old[i],ne[i]);
+            GB_export_errorf("diff by nni at one position not in [-1,1]: %i:%i - %i",diff,old[i],ne[i]);
             GB_print_error();
             continue;

trunk/PARSIMONY/PARS_main.cxx

@@ -1873 +1873 @@
             continue;
         }
-        GB_export_error("Unknown option '%s'",argv[0]);
+        GB_export_errorf("Unknown option '%s'",argv[0]);
         GB_print_error();
         printf("    Options:                Meaning:\n"

trunk/PERL2ARB/ARB_ext.c

@@ -60 +60 @@
     if (!arg){
         free(data);
-        return GB_export_error("Sorry: You never installed a callback '%s:%s'",perl_func,perl_cl);
+        return GB_export_errorf("Sorry: You never installed a callback '%s:%s'",perl_func,perl_cl);
     }else{
         GBS_write_hash(gbp_cp_hash_table,data,0);

trunk/PRIMER_DESIGN/primer_design.cxx

@@ -298 +298 @@
         gb_seq                = GBT_read_sequence( gb_species, alignment );
         if (!gb_seq) {
-            error = GB_export_error("Species '%s' has no data in alignment '%s'", selected_species, alignment);
+            error = GB_export_errorf("Species '%s' has no data in alignment '%s'", selected_species, alignment);
         }
     }
@@ -307 +307 @@
         gb_gene = GEN_find_gene(gb_species, selected_gene);
         if (!gb_gene) {
-            error = GB_export_error("Species '%s' has no gene named '%s'", selected_species, selected_gene);
+            error = GB_export_errorf("Species '%s' has no gene named '%s'", selected_species, selected_gene);
         }
         else {

trunk/PROBE_DESIGN/probe_design.cxx

@@ -513 +513 @@
                     GBDATA *data = GBT_read_sequence(gb_species,ali_name);
                     if (!data) {
-                        aw_message( GB_export_error("Species '%s' has no sequence belonging to alignment '%s'", unames, ali_name));
+                        aw_message( GB_export_errorf("Species '%s' has no sequence belonging to alignment '%s'", unames, ali_name));
                         abort = true;
                     }
@@ -1422 +1422 @@
             int idx = i-'A';
             if (idx<0 || idx>=26 || AWT_iupac_code[idx][index].iupac==0) {
-                err = GB_export_error("Illegal character '%c' in IUPAC-String", i);
+                err = GB_export_errorf("Illegal character '%c' in IUPAC-String", i);
                 break;
             }
@@ -2100 +2100 @@
 
         if (reason) {
-            error = GB_export_error("Error in database format (reason: %s)", reason);
+            error = GB_export_errorf("Error in database format (reason: %s)", reason);
             aws->insert_selection(selList, error, (long)0);
         }
@@ -2107 +2107 @@
     }
     else {
-        error = GB_export_error("Can't open database '%s'", file_name);
+        error = GB_export_errorf("Can't open database '%s'", file_name);
         freeset(pg_global.pg_filename, 0);
     }

trunk/SECEDIT/SEC_graphic.cxx

@@ -608 +608 @@
         GBDATA *gb_species = GBT_find_SAI(gb_main, name);
         if (!gb_species) {
-            err = GB_export_error("Cannot find helix template SAI '%s'",name);
+            err = GB_export_errorf("Cannot find helix template SAI '%s'",name);
         }
         else {
@@ -615 +615 @@
             ali_len = GBT_get_alignment_len(gb_main,ali_name);
             if (ali_len < 10) {
-                err = GB_export_error("alignment '%s' to short to generate helix",ali_name);
+                err = GB_export_errorf("alignment '%s' to short to generate helix",ali_name);
             }
             else {
                 gb_ali = GB_search(gb_species, ali_name, GB_FIND);
                 if (!gb_ali) {
-                    err = GB_export_error("Your helix structure template '%s' has no valid sequence for alignment '%s'", name,ali_name); // no sequence for name in the database !!!
+                    err = GB_export_errorf("Your helix structure template '%s' has no valid sequence for alignment '%s'", name,ali_name); // no sequence for name in the database !!!
                 }
             }

trunk/SECEDIT/SEC_main.cxx

@@ -304 +304 @@
     }
     else {
-        error = GB_export_error("Can't write secondary structure to '%s'", filename);
+        error = GB_export_errorf("Can't write secondary structure to '%s'", filename);
     }
 
@@ -365 +365 @@
 
         if (!in) {
-            error = GB_export_error("Can't open file '%s'", filename);
+            error = GB_export_errorf("Can't open file '%s'", filename);
         }
         else {

trunk/SERVERCNTRL/servercntrl.c

@@ -78 +78 @@
 
     if (!(tcp_id = GBS_read_arb_tcp(arb_tcp_env))) {
-        error = GB_export_error("Entry '%s' in $(ARBHOME)/lib/arb_tcp.dat not found", arb_tcp_env);
+        error = GB_export_errorf("Entry '%s' in $(ARBHOME)/lib/arb_tcp.dat not found", arb_tcp_env);
     }
     else {
@@ -129 +129 @@
 
                 if (!port) {
-                    error = GB_export_error("Error: Missing ':' in line '%s' file $(ARBHOME)/lib/arb_tcp.dat", arb_tcp_env);
+                    error = GB_export_errorf("Error: Missing ':' in line '%s' file $(ARBHOME)/lib/arb_tcp.dat", arb_tcp_env);
                 }
                 else {
@@ -264 +264 @@
 
     if (!(tcp_id = GBS_read_arb_tcp(arb_tcp_env))) {
-        error = GB_export_error("Missing line '%s' in $(ARBHOME)/lib/arb_tcp.dat:",arb_tcp_env);
+        error = GB_export_errorf("Missing line '%s' in $(ARBHOME)/lib/arb_tcp.dat:",arb_tcp_env);
     }
     else {
@@ -274 +274 @@
             /* sprintf(command, "%s -kill -T%s &", server, tcp_id); */
             if (system(command)) {
-                error = GB_export_error("Cannot execute '%s'",command);
+                error = GB_export_errorf("Cannot execute '%s'",command);
             }
             aisc_close(glservercntrl.link);

trunk/SL/AW_NAME/AW_rename.cxx

@@ -349 +349 @@
         }
         else {
-            err = GB_export_error("Generation of short name for '%s' failed", full_name);
+            err = GB_export_errorf("Generation of short name for '%s' failed", full_name);
         }
     }
@@ -679 +679 @@
 
     gb_assert(!result || strlen(result) <= 8);
-    if (!result) GB_export_error("Failed to create unique shortname (prefix='%s')", prefix);
+    if (!result) GB_export_errorf("Failed to create unique shortname (prefix='%s')", prefix);
 
     return result;

trunk/SL/FAST_ALIGNER/fast_aligner.cxx

@@ -133 +133 @@
 
 static inline GB_ERROR species_not_found(GB_CSTR species_name) {
-    return GB_export_error("No species '%s' found!", species_name);
+    return GB_export_errorf("No species '%s' found!", species_name);
 }
 
@@ -141 +141 @@
 
     if (!gbd) {
-        error = GB_export_error("No 'data' found for species '%s'", GBT_read_name(gb_species));
+        error = GB_export_errorf("No 'data' found for species '%s'", GBT_read_name(gb_species));
     }
     else {
@@ -159 +159 @@
         }
         else { // protection error
-            error = GB_export_error("Cannot reverse-complement species '%s' because of protection level", GBT_read_name(gb_species));
+            error = GB_export_errorf("Cannot reverse-complement species '%s' because of protection level", GBT_read_name(gb_species));
         }
 
@@ -1129 +1129 @@
     }
     else {
-        error = GB_export_error("No 'data' found for species '%s'", GBT_read_name(gb_species));
+        error = GB_export_errorf("No 'data' found for species '%s'", GBT_read_name(gb_species));
         if (dataPtr) *dataPtr = NULL; // (user must not care to free data if we fail)
     }
@@ -1150 +1150 @@
     }
     else {
-        error = GB_export_error("Cannot create entry '%s' for '%s'", data_name, GBT_read_name(gb_species));
+        error = GB_export_errorf("Cannot create entry '%s' for '%s'", data_name, GBT_read_name(gb_species));
     }
 
@@ -1498 +1498 @@
             GBDATA *gbd = GBT_read_sequence(gb_toAlign, relSearch.pt_server_alignment); // use a different alignment for next relative search
             if (!gbd) {
-                error = GB_export_error("Species '%s' has no data in alignment '%s'", GBT_read_name(gb_toAlign), relSearch.pt_server_alignment);
+                error = GB_export_errorf("Species '%s' has no data in alignment '%s'", GBT_read_name(gb_toAlign), relSearch.pt_server_alignment);
             }
             else {
@@ -2207 +2207 @@
 
     if (wasNotAllowedToAlign>0) {
-        const char *mess = GB_export_error("%i species were not aligned (because of protection level)", wasNotAllowedToAlign);
+        const char *mess = GB_export_errorf("%i species were not aligned (because of protection level)", wasNotAllowedToAlign);
         aw_popup_ok(mess);
     }
@@ -2213 +2213 @@
     if (err_count) {
         if (error) aw_message(error);
-        error = GB_export_error("Aligner produced %i error%c", err_count, err_count==1 ? '\0' : 's');
+        error = GB_export_errorf("Aligner produced %i error%c", err_count, err_count==1 ? '\0' : 's');
     }
 

trunk/SL/TREE_READ/TreeRead.cxx

@@ -475 +475 @@
     tree_assert(tree||error);
     if (error) {
-        GB_export_error("Import tree: %s", error);
+        GB_export_errorf("Import tree: %s", error);
         tree_assert(!tree);
     }

trunk/SL/TREE_WRITE/TreeWrite.cxx

@@ -225 +225 @@
     FILE     *output = fopen(path, "w");
 
-    if (!output) error = GB_export_error("file '%s' could not be opened for writing", path);
+    if (!output) error = GB_export_errorf("file '%s' could not be opened for writing", path);
     else {
         GB_transaction gb_dummy(gb_main);
@@ -303 +303 @@
     FILE     *output = fopen(path, "w");
 
-    if (!output) error = GB_export_error("file '%s' could not be opened for writing", path);
+    if (!output) error = GB_export_errorf("file '%s' could not be opened for writing", path);
     else {
         GB_transaction gb_dummy(gb_main);

trunk/WINDOW/AW_nawar.cxx

@@ -602 +602 @@
         if (!shown_name) shown_name = default_name;
 
-        GBK_terminate(GBS_global_string("Error loading properties '%s': %s", shown_name, error));
+        GBK_terminatef(GBS_global_string("Error loading properties '%s': %s", shown_name, error));
     }
     return (AW_default) gb_default;

trunk/WINDOW/AW_window.cxx

@@ -3433 +3433 @@
     char *macro_header = GB_read_file("$(ARBHOME)/lib/macro.head");
     if (!macro_header) {
-        return GB_export_error("Cannot open file '%s'", "$(ARBHOME)/lib/macro.head");
+        return GB_export_errorf("Cannot open file '%s'", "$(ARBHOME)/lib/macro.head");
     }
 
@@ -3440 +3440 @@
     if (!prvt->recording_macro_file) {
         delete macro_header;
-        return GB_export_error("Cannot open file '%s' for writing", file);
+        return GB_export_errorf("Cannot open file '%s' for writing", file);
     }
     prvt->stop_action_name = strdup(stop_action_name);
@@ -3498 +3498 @@
         if (!old_cbs->is_equal(*cbs)) {                  // existing remote command replaced by different callback
 #if defined(DEBUG)
-            fprintf(stderr, GBS_global_string("Warning: duplicated use of callback id '%s'\n", old_cbs->id));
+            fputs(GBS_global_string("Warning: duplicated use of callback id '%s'\n", old_cbs->id), stderr);
 #if defined(DEVEL_RALF)
             gb_assert(0);
@@ -3570 +3570 @@
             GBT_write_string(gb_main, awar_result, "");
         } else {
-            aw_message(GB_export_error("Unknown action '%s' in macro", action));
+            aw_message(GB_export_errorf("Unknown action '%s' in macro", action));
             GBT_write_string(gb_main, awar_result, GB_await_error());
         }