Changeset 8319 for trunk

Timestamp:

21/12/11 12:04:21 (5 months ago)

Author:

westram

Message:

• ignored PERL2ARB interface as referrer (to detect functions that are only used from perl)
  • moved several functions to static scope or removed them
  • for some functions it's ok to be only used from perl (e.g. macro support functions). Added comments there!
• there is still some dead code in there, e.g.
  • read-security is implemented, but unused (and unwanted)

Location:

trunk

Files:

• ARBDB/adTest.cxx (modified) (2 diffs)
• ARBDB/ad_core.cxx (modified) (1 diff)
• ARBDB/ad_load.cxx (modified) (1 diff)
• ARBDB/ad_prot.h (modified) (17 diffs)
• ARBDB/ad_save_load.cxx (modified) (1 diff)
• ARBDB/ad_t_prot.h (modified) (6 diffs)
• ARBDB/adali.cxx (modified) (1 diff)
• ARBDB/adcomm.cxx (modified) (1 diff)
• ARBDB/adfile.cxx (modified) (1 diff)
• ARBDB/aditem.cxx (modified) (4 diffs)
• ARBDB/adlang1.cxx (modified) (1 diff)
• ARBDB/admath.cxx (modified) (1 diff)
• ARBDB/adquery.cxx (modified) (1 diff)
• ARBDB/adsocket.cxx (modified) (8 diffs)
• ARBDB/adstring.cxx (modified) (1 diff)
• ARBDB/adtables.cxx (modified) (4 diffs)
• ARBDB/adtools.cxx (modified) (6 diffs)
• ARBDB/arbdb.cxx (modified) (16 diffs)
• ARBDB/gb_prot.h (modified) (1 diff)
• PERL_SCRIPTS/test/Makefile (modified) (1 diff)
• SOURCE_TOOLS/deadcode.pl (modified) (1 diff)

trunk/ARBDB/adTest.cxx

@@ -210 +210 @@
 }
 
-void GB_dump(GBDATA *gbd) {
+NOT4PERL void GB_dump(GBDATA *gbd) {
     int max_lines = 2500;
     GB_dump_internal(gbd, &max_lines);
@@ -219 +219 @@
 }
 
-void GB_dump_no_limit(GBDATA *gbd) {
+NOT4PERL void GB_dump_no_limit(GBDATA *gbd) {
     GB_dump_internal(gbd, 0);
 }

trunk/ARBDB/ad_core.cxx

@@ -321 +321 @@
     gb_write_index_key(GB_FATHER(gbd), gbd->index, new_index);
 }
-
-void gb_rename_entry(GBCONTAINER *gbc, const char *new_key) {
-    GBCONTAINER  *gb_father = GB_FATHER(gbc);
-    GB_MAIN_TYPE *Main      = GBCONTAINER_MAIN(gb_father);
-    GBQUARK       new_keyq;
-    long          new_gbm_index;
-
-    gb_unlink_entry((GBDATA*)gbc);
-
-    new_keyq          = gb_key_2_quark(Main, new_key);
-    new_gbm_index     = GB_QUARK_2_GBMINDEX(Main, new_keyq);
-    GB_GBM_INDEX(gbc) = new_gbm_index;
-
-    gb_link_entry(gb_father, (GBDATA*)gbc, -1);
-    gb_write_key((GBDATA*)gbc, new_key);
-}
-
 
 GBDATA *gb_make_entry(GBCONTAINER * father, const char *key, long index_pos, GBQUARK keyq, GB_TYPES type) {

trunk/ARBDB/ad_load.cxx

@@ -1349 +1349 @@
 }
 
-GBDATA *GB_login(const char *cpath, const char *opent, const char *user) {
+static GBDATA *GB_login(const char *cpath, const char *opent, const char *user) {
     /*! open an ARB database
      *

trunk/ARBDB/ad_prot.h

@@ -67 +67 @@
 const char *GB_get_db_path(GBDATA *gbd);
 void GB_dump_db_path(GBDATA *gbd);
-void GB_dump(GBDATA *gbd);
-void GB_dump_no_limit(GBDATA *gbd);
+NOT4PERL void GB_dump(GBDATA *gbd);
+NOT4PERL void GB_dump_no_limit(GBDATA *gbd);
 GB_ERROR GB_fix_database(GBDATA *gb_main);
 
@@ -74 +74 @@
 void GB_set_verbose(void);
 void GB_set_next_main_idx(long idx);
-GBDATA *GB_login(const char *cpath, const char *opent, const char *user);
 GBDATA *GB_open(const char *path, const char *opent);
 
 /* ad_save_load.cxx */
 GB_ERROR GB_save(GBDATA *gb, const char *path, const char *savetype);
-GB_ERROR GB_create_parent_directory(const char *path);
 GB_ERROR GB_create_directory(const char *path);
 GB_ERROR GB_save_in_arbprop(GBDATA *gb, const char *path, const char *savetype);
@@ -97 +95 @@
 long GB_read_clients(GBDATA *gbd);
 bool GB_is_server(GBDATA *gbd);
-bool GB_is_client(GBDATA *gbd);
 GBDATA *GBCMC_find(GBDATA *gbd, const char *key, GB_TYPES type, const char *str, GB_CASE case_sens, GB_SEARCH_TYPE gbs);
 GB_ERROR GB_tell_server_dont_wait(GBDATA *gbd);
@@ -110 +107 @@
 char *GB_find_all_files(const char *dir, const char *mask, bool filename_only);
 char *GB_find_latest_file(const char *dir, const char *mask);
-const char *GB_existing_file(const char *file, bool warn_when_not_found);
 char *GB_lib_file(bool warn_when_not_found, const char *libprefix, const char *filename);
 char *GB_property_file(bool warn_when_not_found, const char *filename);
@@ -160 +156 @@
 /* adlang1.cxx */
 NOT4PERL void GB_set_export_sequence_hook(gb_export_sequence_cb escb);
-void GB_set_ACISRT_trace(int enable);
 int GB_get_ACISRT_trace(void);
 
@@ -191 +186 @@
 /* admath.cxx */
 double GB_log_fak(int n);
-double GB_frandom(void);
 int GB_random(int range);
 
@@ -201 +195 @@
 
 /* adquery.cxx */
-const char *GB_get_GBDATA_path(GBDATA *gbd);
 GBDATA *GB_find_sub_by_quark(GBDATA *father, GBQUARK key_quark, GBDATA *after, size_t skip_over);
 GBDATA *GB_find(GBDATA *gbd, const char *key, GB_SEARCH_TYPE gbs);
@@ -234 +227 @@
 GB_ULONG GB_last_saved_time(GBDATA *gb_main);
 GB_ERROR GB_textprint(const char *path) __ATTR__USERESULT;
-GB_ERROR GB_xterm(void) __ATTR__USERESULT;
-GB_ERROR GB_xcmd(const char *cmd, bool background, bool wait_only_if_error) __ATTR__USERESULT_TODO;
 char *GB_executable(GB_CSTR exe_name);
-void GB_setenv(const char *var, const char *value);
-GB_CSTR GB_getenvARB_XTERM(void);
-GB_CSTR GB_getenvARB_XCMD(void);
 GB_CSTR GB_getenvUSER(void);
-GB_CSTR GB_getenvHOME(void);
 GB_CSTR GB_getenvARBHOME(void);
 GB_CSTR GB_getenvARBMACRO(void);
 GB_CSTR GB_getenvARBMACROHOME(void);
-GB_CSTR GB_getenvARBCONFIG(void);
-GB_CSTR GB_getenvPATH(void);
 GB_CSTR GB_getenvARB_GS(void);
 GB_CSTR GB_getenvARB_PDFVIEW(void);
@@ -256 +241 @@
 bool GB_host_is_local(const char *hostname);
 GB_ULONG GB_get_physical_memory(void);
+GB_ERROR GB_xterm(void) __ATTR__USERESULT;
+GB_ERROR GB_xcmd(const char *cmd, bool background, bool wait_only_if_error) __ATTR__USERESULT_TODO;
 GB_CSTR GB_append_suffix(const char *name, const char *suffix);
 GB_CSTR GB_canonical_path(const char *anypath);
@@ -272 +259 @@
 
 /* adstring.cxx */
-void GB_raise_critical_error(const char *msg) __ATTR__NORETURN;
 char *GBS_string_2_key(const char *str);
 char *GB_memdup(const char *source, size_t len);
@@ -327 +313 @@
 GB_BUFFER GB_give_other_buffer(GB_CBUFFER buffer, long size);
 void GB_atexit(void (*exitfun)());
-void GB_exit_gb(void);
 void GB_init_gb(void);
 int GB_open_DBs(void);
@@ -343 +328 @@
 long GB_read_string_count(GBDATA *gbd);
 GB_CSTR GB_read_link_pntr(GBDATA *gbd);
-char *GB_read_link(GBDATA *gbd);
-long GB_read_link_count(GBDATA *gbd);
 long GB_read_bits_count(GBDATA *gbd);
 GB_CSTR GB_read_bits_pntr(GBDATA *gbd, char c_0, char c_1);
@@ -355 +338 @@
 GB_UINT4 *GB_read_ints(GBDATA *gbd);
 GB_CFLOAT *GB_read_floats_pntr(GBDATA *gbd);
-long GB_read_floats_count(GBDATA *gbd);
 char *GB_read_as_string(GBDATA *gbd);
 long GB_read_from_ints(GBDATA *gbd, long index);
@@ -374 +356 @@
 int GB_read_security_read(GBDATA *gbd);
 int GB_read_security_delete(GBDATA *gbd);
-int GB_get_my_security(GBDATA *gbd);
 GB_ERROR GB_write_security_write(GBDATA *gbd, unsigned long level);
 GB_ERROR GB_write_security_read(GBDATA *gbd, unsigned long level);
@@ -394 +375 @@
 GBDATA *GB_get_root(GBDATA *gbd);
 bool GB_check_father(GBDATA *gbd, GBDATA *gb_maybefather);
-int GB_rename(GBDATA *gbc, const char *new_key);
 GBDATA *GB_create(GBDATA *father, const char *key, GB_TYPES type);
 GBDATA *GB_create_container(GBDATA *father, const char *key);
@@ -406 +386 @@
 bool GB_is_temporary(GBDATA *gbd);
 bool GB_in_temporary_branch(GBDATA *gbd);
-GB_ERROR GB_push_local_transaction(GBDATA *gbd);
-GB_ERROR GB_pop_local_transaction(GBDATA *gbd);
 GB_ERROR GB_push_transaction(GBDATA *gbd);
 GB_ERROR GB_pop_transaction(GBDATA *gbd);
@@ -427 +405 @@
 void GB_remove_all_callbacks_to(GBDATA *gbd, GB_CB_TYPE type, GB_CB func);
 GB_ERROR GB_ensure_callback(GBDATA *gbd, GB_CB_TYPE type, GB_CB func, int *clientdata);
-GB_ERROR GB_release(GBDATA *gbd);
-int GB_testlocal(GBDATA *gbd);
 int GB_nsons(GBDATA *gbd);
 void GB_disable_quicksave(GBDATA *gbd, const char *reason);
 GB_ERROR GB_resort_data_base(GBDATA *gb_main, GBDATA **new_order_list, long listsize);
 GB_ERROR GB_resort_system_folder_to_top(GBDATA *gb_main);
-GB_ERROR GB_write_usr_public(GBDATA *gbd, long flags);
-long GB_read_usr_public(GBDATA *gbd);
 long GB_read_usr_private(GBDATA *gbd);
 GB_ERROR GB_write_usr_private(GBDATA *gbd, long ref);

trunk/ARBDB/ad_save_load.cxx

@@ -850 +850 @@
 }
 
-GB_ERROR GB_create_parent_directory(const char *path) {
+static GB_ERROR GB_create_parent_directory(const char *path) {
     GB_ERROR error = NULL;
     char *parent;

trunk/ARBDB/ad_t_prot.h

@@ -47 +47 @@
 long GBT_get_alignment_len(GBDATA *gb_main, const char *aliname);
 GB_ERROR GBT_set_alignment_len(GBDATA *gb_main, const char *aliname, long new_len);
-int GBT_get_alignment_aligned(GBDATA *gb_main, const char *aliname);
 char *GBT_get_alignment_type_string(GBDATA *gb_main, const char *aliname);
 GB_alignment_type GBT_get_alignment_type(GBDATA *gb_main, const char *aliname);
@@ -64 +63 @@
 GBDATA *GBT_find_or_create_SAI(GBDATA *gb_main, const char *name);
 GBDATA *GBT_find_item_rel_item_data(GBDATA *gb_item_data, const char *id_field, const char *id_value);
-GBDATA *GBT_expect_item_rel_item_data(GBDATA *gb_item_data, const char *id_field, const char *id_value);
 GBDATA *GBT_get_species_data(GBDATA *gb_main);
 GBDATA *GBT_first_marked_species_rel_species_data(GBDATA *gb_species_data);
@@ -76 +74 @@
 GBDATA *GBT_expect_species(GBDATA *gb_main, const char *name);
 GBDATA *GBT_get_SAI_data(GBDATA *gb_main);
-GBDATA *GBT_first_marked_SAI_rel_SAI_data(GBDATA *gb_sai_data);
-GBDATA *GBT_next_marked_SAI(GBDATA *gb_sai);
 GBDATA *GBT_first_SAI_rel_SAI_data(GBDATA *gb_sai_data);
 GBDATA *GBT_first_SAI(GBDATA *gb_main);
@@ -84 +80 @@
 GBDATA *GBT_find_SAI(GBDATA *gb_main, const char *name);
 GBDATA *GBT_expect_SAI(GBDATA *gb_main, const char *name);
-long GBT_get_item_count(GBDATA *gb_parent_of_container, const char *item_container_name);
 long GBT_get_species_count(GBDATA *gb_main);
 long GBT_get_SAI_count(GBDATA *gb_main);
-char *GBT_create_unique_item_identifier(GBDATA *gb_item_container, const char *id_field, const char *default_id);
 char *GBT_create_unique_species_name(GBDATA *gb_main, const char *default_name);
 void GBT_mark_all(GBDATA *gb_main, int flag);
@@ -115 +109 @@
 GBDATA *GBT_next_table(GBDATA *gb_table);
 GBDATA *GBT_first_table_entry(GBDATA *gb_table);
-GBDATA *GBT_first_marked_table_entry(GBDATA *gb_table);
 GBDATA *GBT_next_table_entry(GBDATA *gb_table_entry);
-GBDATA *GBT_next_marked_table_entry(GBDATA *gb_table_entry);
-GBDATA *GBT_find_table_entry(GBDATA *gb_table, const char *id);
-GBDATA *GBT_open_table_entry(GBDATA *gb_table, const char *id);
 GBDATA *GBT_first_table_field(GBDATA *gb_table);
-GBDATA *GBT_first_marked_table_field(GBDATA *gb_table);
 GBDATA *GBT_next_table_field(GBDATA *gb_table_field);
-GBDATA *GBT_next_marked_table_field(GBDATA *gb_table_field);
 GBDATA *GBT_find_table_field(GBDATA *gb_table, const char *id);
-GB_TYPES GBT_get_type_of_table_entry_field(GBDATA *gb_table, const char *fieldname);
-GB_ERROR GBT_savely_write_table_entry_field(GBDATA *gb_table, GBDATA *gb_entry, const char *fieldname, const char *value_in_ascii_format);
 GBDATA *GBT_open_table_field(GBDATA *gb_table, const char *fieldname, GB_TYPES type_of_field);
 
@@ -151 +137 @@
 GB_ERROR GBT_write_byte(GBDATA *gb_container, const char *fieldpath, unsigned char content);
 GB_ERROR GBT_write_float(GBDATA *gb_container, const char *fieldpath, double content);
-GBDATA *GB_test_link_follower(GBDATA *gb_main, GBDATA *gb_link, const char *link);
 GBDATA *GBT_open(const char *path, const char *opent);
 GB_ERROR GBT_remote_action(GBDATA *gb_main, const char *application, const char *action_name);
 GB_ERROR GBT_remote_awar(GBDATA *gb_main, const char *application, const char *awar_name, const char *value);
 GB_ERROR GBT_remote_read_awar(GBDATA *gb_main, const char *application, const char *awar_name);
-const char *GBT_remote_touch_awar(GBDATA *gb_main, const char *application, const char *awar_name);
 char *GB_generate_notification(GBDATA *gb_main, void (*cb)(const char *message, void *client_data), const char *message, void *client_data);
 GB_ERROR GB_remove_last_notification(GBDATA *gb_main);

trunk/ARBDB/adali.cxx

@@ -734 +734 @@
 }
 
-int GBT_get_alignment_aligned(GBDATA *gb_main, const char *aliname) {
-    GBDATA *gb_alignment = GBT_get_alignment(gb_main, aliname);
-    return gb_alignment ? *GBT_read_int(gb_alignment, "aligned") : -1;
-}
-
 char *GBT_get_alignment_type_string(GBDATA *gb_main, const char *aliname) {
     char   *result       = NULL;

trunk/ARBDB/adcomm.cxx

@@ -1655 +1655 @@
     return Main->local_mode;
 }
-bool GB_is_client(GBDATA *gbd) {
-    return !GB_is_server(gbd);
-}
-
 static GB_ERROR gbcmc_unfold_list(int socket, GBDATA * gbd)
 {

trunk/ARBDB/adfile.cxx

@@ -195 +195 @@
 }
 
-const char *GB_existing_file(const char *file, bool warn_when_not_found) {
+static const char *GB_existing_file(const char *file, bool warn_when_not_found) {
     // return 'file' if it's an existing readable file
     // return NULL otherwise

trunk/ARBDB/aditem.cxx

@@ -85 +85 @@
 }
 
-GBDATA *GBT_expect_item_rel_item_data(GBDATA *gb_item_data, const char *id_field, const char *id_value) {
+static GBDATA *GBT_expect_item_rel_item_data(GBDATA *gb_item_data, const char *id_field, const char *id_value) {
     //! like GBT_find_item_rel_item_data(), but also exports an error if the item is not present
 
@@ -150 +150 @@
 }
 
-GBDATA *GBT_first_marked_SAI_rel_SAI_data(GBDATA *gb_sai_data) {
-    return GB_first_marked(gb_sai_data, "extended");
-}
-
-GBDATA *GBT_next_marked_SAI(GBDATA *gb_sai) {
-    gb_assert(GB_has_key(gb_sai, "extended"));
-    return GB_next_marked(gb_sai, "extended");
-}
-
 // Search SAIs
 GBDATA *GBT_first_SAI_rel_SAI_data(GBDATA *gb_sai_data) {
@@ -192 +183 @@
 //      count items
 
-long GBT_get_item_count(GBDATA *gb_parent_of_container, const char *item_container_name) {
+static long GBT_get_item_count(GBDATA *gb_parent_of_container, const char *item_container_name) {
     // returns elements stored in a container
 
@@ -216 +207 @@
 // --------------------------------------------------------------------------------
 
-char *GBT_create_unique_item_identifier(GBDATA *gb_item_container, const char *id_field, const char *default_id) {
+static char *GBT_create_unique_item_identifier(GBDATA *gb_item_container, const char *id_field, const char *default_id) {
     // returns an identifier not used by items in 'gb_item_container'
     // 'id_field' is the entry that is used as identifier (e.g. 'name' for species)

trunk/ARBDB/adlang1.cxx

@@ -36 +36 @@
 static int trace = 0;
 
-void GB_set_ACISRT_trace(int enable) { trace = enable; }
+static void GB_set_ACISRT_trace(int enable) { trace = enable; }
 int GB_get_ACISRT_trace() { return trace; }
 

trunk/ARBDB/admath.cxx

@@ -40 +40 @@
 static int randomSeeded = 0;
 
-double GB_frandom() {
-    // produces a random number in range [0.0 .. 1.0]
-    if (!randomSeeded) {
-        srand(time(0));
-        randomSeeded = 1;
-    }
-    return ((double)rand())/RAND_MAX;
-}
-
 int GB_random(int range) {
     // produces a random number in range [0 .. range-1]

trunk/ARBDB/adquery.cxx

@@ -42 +42 @@
 #define BUFFERSIZE 1024
 
-const char *GB_get_GBDATA_path(GBDATA *gbd) {
+static const char *GB_get_GBDATA_path(GBDATA *gbd) {
     static char *orgbuffer = NULL;
     char        *buffer;

trunk/ARBDB/adsocket.cxx

@@ -517 +517 @@
 }
 
-GB_ERROR GB_xterm() {
-    // goes to header: __ATTR__USERESULT
-    const char *xt      = GB_getenvARB_XTERM();
-    const char *command = GBS_global_string("%s &", xt);
-    return GBK_system(command);
-}
-
-GB_ERROR GB_xcmd(const char *cmd, bool background, bool wait_only_if_error) {
-    // goes to header: __ATTR__USERESULT_TODO
-
-    // runs a command in an xterm
-    // if 'background' is true -> run asynchronous
-    // if 'wait_only_if_error' is true -> asynchronous does wait for keypress only if cmd fails
-
-    GBS_strstruct *strstruct = GBS_stropen(1024);
-    const char    *xcmd      = GB_getenvARB_XCMD();
-
-    GBS_strcat(strstruct, "(");
-    GBS_strcat(strstruct, xcmd);
-    GBS_strcat(strstruct, " bash -c 'LD_LIBRARY_PATH=\"");
-    GBS_strcat(strstruct, GB_getenv("LD_LIBRARY_PATH"));
-    GBS_strcat(strstruct, "\";export LD_LIBRARY_PATH; (");
-    GBS_strcat(strstruct, cmd);
-
-    if (background) {
-        if (wait_only_if_error) {
-            GBS_strcat(strstruct, ") || (echo; echo Press RETURN to close Window; read a)' ) &");
+// --------------------------------------------------------------------------------
+
+static GB_CSTR getenv_ignore_empty(GB_CSTR envvar) {
+    GB_CSTR result = getenv(envvar);
+    return (result && result[0]) ? result : 0;
+}
+
+static GB_CSTR GB_getenvPATH() {
+    static const char *path = 0;
+    if (!path) {
+        path = getenv_ignore_empty("PATH");
+        if (!path) {
+            path = GBS_eval_env("/bin:/usr/bin:$(ARBHOME)/bin");
+            GB_informationf("Your PATH variable is empty - using '%s' as search path.", path);
         }
         else {
-            GBS_strcat(strstruct, "; echo; echo Press RETURN to close Window; read a)' ) &");
-        }
-    }
-    else {
-        if (wait_only_if_error) {
-            GBS_strcat(strstruct, ") || (echo; echo Press RETURN to close Window; read a)' )");
-        }
-        else { // no wait
-            GBS_strcat(strstruct, " )' ) ");
-        }
-    }
-
-    GB_ERROR error = GBK_system(GBS_mempntr(strstruct));
-    GBS_strforget(strstruct);
-
-    return error;
+            char *arbbin = GBS_eval_env("$(ARBHOME)/bin");
+            if (strstr(path, arbbin) == 0) {
+                GB_warningf("Your PATH variable does not contain '%s'. Things may not work as expected.", arbbin);
+            }
+            free(arbbin);
+        }
+    }
+    return path;
 }
 
@@ -635 +614 @@
 // Functions to access the environment variables used by ARB:
 
-static GB_CSTR getenv_ignore_empty(GB_CSTR envvar) {
-    GB_CSTR result = getenv(envvar);
-    return (result && result[0]) ? result : 0;
-}
-
 static char *getenv_executable(GB_CSTR envvar) {
     // get full path of executable defined by 'envvar'
@@ -680 +654 @@
 }
 
-void GB_setenv(const char *var, const char *value) {
+static void GB_setenv(const char *var, const char *value) {
     if (setenv(var, value, 1) != 0) {
         GB_warningf("Could not set environment variable '%s'. This might cause problems in subprocesses.\n"
@@ -687 +661 @@
 }
 
-GB_CSTR GB_getenvARB_XTERM() {
+static GB_CSTR GB_getenvARB_XTERM() {
     static const char *xterm = 0;
     if (!xterm) {
@@ -696 +670 @@
 }
 
-GB_CSTR GB_getenvARB_XCMD() {
+static GB_CSTR GB_getenvARB_XCMD() {
     static const char *xcmd = 0;
     if (!xcmd) {
@@ -727 +701 @@
 
 
-GB_CSTR GB_getenvHOME() {
+static GB_CSTR GB_getenvHOME() {
     static SmartCharPtr Home;
     if (Home.isNull()) {
@@ -787 +761 @@
 }
 
-GB_CSTR GB_getenvARBCONFIG() {
+static GB_CSTR GB_getenvARBCONFIG() {
     static const char *ac = 0;
     if (!ac) ac = getenv_autodirectory("ARBCONFIG", GB_path_in_arbprop("cfgSave")); // doc in ../HELP_SOURCE/oldhelp/arb_envar.hlp@ARBCONFIG
     return ac;
-}
-
-GB_CSTR GB_getenvPATH() {
-    static const char *path = 0;
-    if (!path) {
-        path = getenv_ignore_empty("PATH");
-        if (!path) {
-            path = GBS_eval_env("/bin:/usr/bin:$(ARBHOME)/bin");
-            GB_informationf("Your PATH variable is empty - using '%s' as search path.", path);
-        }
-        else {
-            char *arbbin = GBS_eval_env("$(ARBHOME)/bin");
-            if (strstr(path, arbbin) == 0) {
-                GB_warningf("Your PATH variable does not contain '%s'. Things may not work as expected.", arbbin);
-            }
-            free(arbbin);
-        }
-    }
-    return path;
 }
 
@@ -988 +943 @@
 }
 
+// ---------------------------
+//      external commands
+
+GB_ERROR GB_xterm() {
+    // goes to header: __ATTR__USERESULT
+    const char *xt      = GB_getenvARB_XTERM();
+    const char *command = GBS_global_string("%s &", xt);
+    return GBK_system(command);
+}
+
+GB_ERROR GB_xcmd(const char *cmd, bool background, bool wait_only_if_error) {
+    // goes to header: __ATTR__USERESULT_TODO
+
+    // runs a command in an xterm
+    // if 'background' is true -> run asynchronous
+    // if 'wait_only_if_error' is true -> asynchronous does wait for keypress only if cmd fails
+
+    GBS_strstruct *strstruct = GBS_stropen(1024);
+    const char    *xcmd      = GB_getenvARB_XCMD();
+
+    GBS_strcat(strstruct, "(");
+    GBS_strcat(strstruct, xcmd);
+    GBS_strcat(strstruct, " bash -c 'LD_LIBRARY_PATH=\"");
+    GBS_strcat(strstruct, GB_getenv("LD_LIBRARY_PATH"));
+    GBS_strcat(strstruct, "\";export LD_LIBRARY_PATH; (");
+    GBS_strcat(strstruct, cmd);
+
+    if (background) {
+        if (wait_only_if_error) {
+            GBS_strcat(strstruct, ") || (echo; echo Press RETURN to close Window; read a)' ) &");
+        }
+        else {
+            GBS_strcat(strstruct, "; echo; echo Press RETURN to close Window; read a)' ) &");
+        }
+    }
+    else {
+        if (wait_only_if_error) {
+            GBS_strcat(strstruct, ") || (echo; echo Press RETURN to close Window; read a)' )");
+        }
+        else { // no wait
+            GBS_strcat(strstruct, " )' ) ");
+        }
+    }
+
+    GB_ERROR error = GBK_system(GBS_mempntr(strstruct));
+    GBS_strforget(strstruct);
+
+    return error;
+}
+
 // ---------------------------------------------
 // path completion (parts former located in AWT)

trunk/ARBDB/adstring.cxx

@@ -26 +26 @@
 
 #include <valgrind.h>
-
-// -----------------------
-//      error handling
-
-void GB_raise_critical_error(const char *msg) {
-    // goes to header: __ATTR__NORETURN
-    fprintf(stderr, "------------------------------------------------------------\n");
-    fprintf(stderr, "A critical error occurred in ARB\nError-Message: %s\n", msg);
-#if defined(DEBUG)
-    fprintf(stderr, "Run the debugger to find the location where the error was raised.\n");
-#endif // DEBUG
-    fprintf(stderr, "------------------------------------------------------------\n");
-    gb_assert(0);
-    exit(-1);
-}
-
-// --------------------------------------------------------------------------------
-
 
 static char *GBS_string_2_key_with_exclusions(const char *str, const char *additional) {

trunk/ARBDB/adtables.cxx

@@ -40 +40 @@
  *      }
  */
+
+static GBDATA *GBT_find_table_entry(GBDATA *gb_table, const char *id) {
+    GBDATA *gb_entries = GB_entry(gb_table, "entries");
+    GBDATA *gb_entry_name = GB_find_string(gb_entries, "name", id, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
+    if (!gb_entry_name) return NULL;
+    return GB_get_father(gb_entry_name);
+}
 
 static GBDATA *gbt_table_link_follower(GBDATA *gb_main, GBDATA */*gb_link*/, const char *link) {
@@ -140 +147 @@
 }
 
-GBDATA *GBT_first_marked_table_entry(GBDATA *gb_table) {
-    GBDATA *gb_entries = GB_entry(gb_table, "entries");
-    return GB_first_marked(gb_entries, "entry");
-}
-
 GBDATA *GBT_next_table_entry(GBDATA *gb_table_entry) {
     gb_assert(GB_has_key(gb_table_entry, "entry"));
     return GB_nextEntry(gb_table_entry);
-}
-
-GBDATA *GBT_next_marked_table_entry(GBDATA *gb_table_entry) {
-    return GB_next_marked(gb_table_entry, "entry");
-}
-
-GBDATA *GBT_find_table_entry(GBDATA *gb_table, const char *id) {
-    GBDATA *gb_entries = GB_entry(gb_table, "entries");
-    GBDATA *gb_entry_name = GB_find_string(gb_entries, "name", id, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
-    if (!gb_entry_name) return NULL;
-    return GB_get_father(gb_entry_name);
-}
-
-GBDATA *GBT_open_table_entry(GBDATA *gb_table, const char *id) {
-    GBDATA *gb_entries = GB_entry(gb_table, "entries");
-    GBDATA *gb_entry_name = GB_find_string(gb_entries, "name", id, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
-    GBDATA *gb_entry;
-    if (gb_entry_name) GB_get_father(gb_entry_name);
-    gb_entry = GB_create_container(gb_entries, "entry");
-    gb_entry_name = GB_create(gb_entry, "name", GB_STRING);
-    GB_write_string(gb_entry_name, id);
-    return gb_entry;
 }
 
@@ -177 +157 @@
 }
 
-GBDATA *GBT_first_marked_table_field(GBDATA *gb_table) {
-    GBDATA *gb_fields = GB_entry(gb_table, "fields");
-    return GB_first_marked(gb_fields, "field");
-}
 GBDATA *GBT_next_table_field(GBDATA *gb_table_field) {
     gb_assert(GB_has_key(gb_table_field, "field"));
     return GB_nextEntry(gb_table_field);
-}
-
-GBDATA *GBT_next_marked_table_field(GBDATA *gb_table_field) {
-    return GB_next_marked(gb_table_field, "field");
 }
 
@@ -195 +167 @@
     if (!gb_field_name) return NULL;
     return GB_get_father(gb_field_name);
-}
-
-GB_TYPES GBT_get_type_of_table_entry_field(GBDATA *gb_table, const char *fieldname) {
-    GBDATA *gb_fields = GB_entry(gb_table, "fields");
-    GBDATA *gb_field_name = GB_find_string(gb_fields, "name", fieldname, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
-    GBDATA *gb_field_type;
-    if (!gb_field_name) return GB_NONE;
-    gb_field_type = GB_entry(gb_field_name, "type");
-    return (GB_TYPES) GB_read_int(gb_field_type);
-}
-
-GB_ERROR GBT_savely_write_table_entry_field(GBDATA *gb_table, GBDATA *gb_entry, const char *fieldname, const char *value_in_ascii_format) {
-    GBDATA *gb_entry_field;
-    GB_TYPES type = GBT_get_type_of_table_entry_field(gb_table, fieldname);
-    if (type == GB_NONE) {
-        return GB_export_errorf("There is no field description '%s' for your table", fieldname);
-    }
-    gb_entry_field = GB_search(gb_entry, "fieldname", type);
-    return GB_write_as_string(gb_entry_field, value_in_ascii_format);
 }
 

trunk/ARBDB/adtools.cxx

@@ -515 +515 @@
 
 
-GBDATA *GB_test_link_follower(GBDATA *gb_main, GBDATA *gb_link, const char *link) {
+static GBDATA *GB_test_link_follower(GBDATA *gb_main, GBDATA *gb_link, const char *link) {
     GBDATA *linktarget = GB_search(gb_main, "tmp/link/string", GB_STRING);
     // GBUSE(gb_link);
@@ -589 +589 @@
  * - BIO::remote_action         (use of GBT_remote_action)
  * - BIO::remote_awar           (use of GBT_remote_awar)
- * - BIO::remote_read_awar      (use of GBT_remote_read_awar - seems unused)
- * - BIO::remote_touch_awar     (use of GBT_remote_touch_awar - seems unused)
+ * - BIO::remote_read_awar      (use of GBT_remote_read_awar)
  */
 
@@ -658 +657 @@
 
 GB_ERROR GBT_remote_action(GBDATA *gb_main, const char *application, const char *action_name) {
+    // needs to be public (needed by perl-macros)
+
     remote_awars  awars;
     GBDATA       *gb_action;
@@ -674 +675 @@
 
 GB_ERROR GBT_remote_awar(GBDATA *gb_main, const char *application, const char *awar_name, const char *value) {
+    // needs to be public (needed by perl-macros)
+
     remote_awars  awars;
     GBDATA       *gb_awar;
@@ -692 +695 @@
 
 GB_ERROR GBT_remote_read_awar(GBDATA *gb_main, const char *application, const char *awar_name) {
+    // needs to be public (needed by perl-macros)
+
     remote_awars  awars;
     GBDATA       *gb_awar;
@@ -707 +712 @@
     return error;
 }
-
-const char *GBT_remote_touch_awar(GBDATA *gb_main, const char *application, const char *awar_name) {
-    remote_awars  awars;
-    GBDATA       *gb_awar;
-    GB_ERROR      error = NULL;
-
-    gbt_build_remote_awars(&awars, application);
-    gb_awar = gbt_remote_search_awar(gb_main, awars.awar_awar);
-
-    error             = GB_begin_transaction(gb_main);
-    if (!error) error = GB_write_string(gb_awar, awar_name);
-    if (!error) error = GBT_write_string(gb_main, awars.awar_action, "AWAR_REMOTE_TOUCH");
-    error             = GB_end_transaction(gb_main, error);
-
-    if (!error) error = gbt_wait_for_remote_action(gb_main, gb_awar, awars.awar_result);
-    return error;
-}
-
 
 // ---------------------------

trunk/ARBDB/arbdb.cxx

@@ -392 +392 @@
 }
 
-void GB_exit_gb() {
+static void GB_exit_gb() {
     GB_shell::ensure_inside();
 
@@ -803 +803 @@
 }
 
-char *GB_read_link(GBDATA *gbd)
+static char *GB_read_link(GBDATA *gbd)
 {
     const char *d;
@@ -811 +811 @@
     return GB_memdup(d, GB_GETSIZE(gbd)+1);
 }
-
-long GB_read_link_count(GBDATA *gbd)
-{
-    GB_TEST_READ(gbd, GB_LINK, "GB_read_link_pntr");
-    return GB_GETSIZE(gbd);
-}
-
 
 long GB_read_bits_count(GBDATA *gbd)
@@ -902 +895 @@
 }
 
-long GB_read_ints_count(GBDATA *gbd)
-{
+long GB_read_ints_count(GBDATA *gbd) { // used by ../PERL_SCRIPTS/SAI/SAI.pm@read_ints_count
     GB_TEST_READ(gbd, GB_INTS, "GB_read_ints_count");
     return GB_GETSIZE(gbd);
@@ -947 +939 @@
 }
 
-long GB_read_floats_count(GBDATA *gbd)
+static long GB_read_floats_count(GBDATA *gbd)
 {
     GB_TEST_READ(gbd, GB_FLOATS, "GB_read_floats_count");
@@ -980 +972 @@
 //      array type access functions (intended for perl use)
 
-long GB_read_from_ints(GBDATA *gbd, long index) {
+long GB_read_from_ints(GBDATA *gbd, long index) { // used by ../PERL_SCRIPTS/SAI/SAI.pm@read_from_ints
     static GBDATA    *last_gbd = 0;
     static long       count    = 0;
@@ -1330 +1322 @@
     return GB_GET_SECURITY_DELETE(gbd);
 }
-int GB_get_my_security(GBDATA *gbd) {
-    return GB_MAIN(gbd)->security_level;
-}
-
 GB_ERROR GB_write_security_write(GBDATA *gbd, unsigned long level)
 {
@@ -1347 +1335 @@
     return 0;
 }
-GB_ERROR GB_write_security_read(GBDATA *gbd, unsigned long level)
+GB_ERROR GB_write_security_read(GBDATA *gbd, unsigned long level) // @@@ unused 
 {
     GB_MAIN_TYPE *Main = GB_MAIN(gbd);
@@ -1359 +1347 @@
     return 0;
 }
-
 GB_ERROR GB_write_security_delete(GBDATA *gbd, unsigned long level)
 {
@@ -1472 +1459 @@
     //
     // Other uses (maybe just to pass GB_MAIN_TYPE instead of GBDATA as GB_key_2_quark likes):
-    // - gb_rename_entry
     // - gb_make_entry
     // - compress_sequence_tree
@@ -1568 +1554 @@
     gb_touch_entry((GBDATA *)gbd, GB_CREATED);
     return (GBDATA *)gbd;
-}
-
-static void gb_rename(GBCONTAINER *gbc, const char *new_key) {
-    gb_rename_entry(gbc, new_key);
-}
-
-int GB_rename(GBDATA *gbc, const char *new_key) {
-    /*! User accessible rename, check everything
-     * returns 0 if successful!
-     */
-    GBCONTAINER *old_father, *new_father;
-    if (GB_check_key(new_key)) {
-        GB_print_error();
-        return -1;
-    }
-
-    GB_test_transaction(gbc);
-    old_father = GB_FATHER(gbc);
-
-    if (GB_TYPE(gbc) != GB_DB) {
-        GB_internal_error("GB_rename has to be called with container");
-        return -1;
-    }
-
-    gb_rename((GBCONTAINER*)gbc, new_key);
-
-    new_father = GB_FATHER(gbc);
-    if (old_father != new_father) {
-        GB_internal_error("father changed during rename");
-        return -1;
-    }
-
-    gb_touch_header(new_father);
-    gb_touch_entry(gbc, GB_NORMAL_CHANGE);
-
-    return 0;
 }
 
@@ -1984 +1934 @@
 }
 
-GB_ERROR GB_clear_temporary(GBDATA *gbd) {
+GB_ERROR GB_clear_temporary(GBDATA *gbd) { // @@@ used in ptpan branch - do not remove
     //! undo effect of GB_set_temporary()
 
@@ -1999 +1949 @@
 }
 
-bool GB_in_temporary_branch(GBDATA *gbd) {
+bool GB_in_temporary_branch(GBDATA *gbd) { // @@@ used in ptpan branch - do not remove
     /*! @return true, if 'gbd' is member of a temporary subtree,
      * i.e. if GB_is_temporary(itself or any parent)
@@ -2015 +1965 @@
 //      transactions
 
-
-GB_ERROR GB_push_local_transaction(GBDATA *gbd) {
-    /*! Starts a read only transaction.
-     * Be sure that all data is cached. Be extremely careful!
-     */
-    GB_MAIN_TYPE *Main = GB_MAIN(gbd);
-    if (Main->transaction>0) {
-        return GB_push_transaction(gbd);
-    }
-    Main->transaction --;
-    return 0;
-}
-
-GB_ERROR GB_pop_local_transaction(GBDATA *gbd) {
-    /*! Stops a read only transaction.
-     * Be sure that all data is cached!
-     */
-
-    GB_MAIN_TYPE *Main = GB_MAIN(gbd);
-    if (Main->transaction>0) {
-        return GB_pop_transaction(gbd);
-    }
-    Main->transaction ++;
-    return 0;
-}
 
 GB_ERROR GB_push_transaction(GBDATA *gbd) {
@@ -2629 +2554 @@
 }
 
-GB_ERROR GB_release(GBDATA *gbd) {
-    /*! free cached data in client.
-     *
-     * Warning: pointers into the freed region(s) will get invalid!
-     */
-    GBCONTAINER  *gbc;
-    GBDATA       *gb;
-    int           index;
-    GB_MAIN_TYPE *Main = GB_MAIN(gbd);
-
-    GB_test_transaction(gbd);
-    if (Main->local_mode) return 0;
-    if (GB_ARRAY_FLAGS(gbd).changed && !gbd->flags2.update_in_server) {
-        GB_update_server(gbd);
-    }
-    if (GB_TYPE(gbd) != GB_DB) {
-        GB_ERROR error = GB_export_errorf("You cannot release non container (%s)",
-                                          GB_read_key_pntr(gbd));
-        GB_internal_error(error);
-        return error;
-    }
-    if (gbd->flags2.folded_container) return 0;
-    gbc = (GBCONTAINER *)gbd;
-
-    for (index = 0; index < gbc->d.nheader; index++) {
-        if ((gb = GBCONTAINER_ELEM(gbc, index))) {
-            gb_delete_entry(&gb);
-        }
-    }
-
-    gbc->flags2.folded_container = 1;
-    gb_do_callback_list(Main);       // do all callbacks
-    return 0;
-}
-
-int GB_testlocal(GBDATA *gbd) {
-    /*! test whether data is available as local data
-     *
-     * @return 1 if data is available
-     *
-     * important for callbacks, because only testlocal tested data is available
-     */
-    if (GB_TYPE(gbd) != GB_DB) return 1;            // all non-containers are available
-    if (GB_MAIN(gbd)->local_mode) return 1;         // everything is available in server
-    if (gbd->flags2.folded_container) return 0;
-    return 1;
-}
-
 int GB_nsons(GBDATA *gbd) {
     /*! return number of child entries
@@ -2765 +2642 @@
     free(new_order_list);
     return error;
-}
-
-// -------------------
-//      user flags
-
-GB_ERROR GB_write_usr_public(GBDATA *gbd, long flags) {
-    GB_test_transaction(gbd);
-    if (GB_GET_SECURITY_WRITE(gbd) > GB_MAIN(gbd)->security_level)
-        return gb_security_error(gbd);
-    gbd->flags.user_flags = flags;
-    gb_touch_entry(gbd, GB_NORMAL_CHANGE);
-    return 0;
-}
-
-long GB_read_usr_public(GBDATA *gbd)
-{
-    GB_test_transaction(gbd);
-    return (long)gbd->flags.user_flags;
 }
 

trunk/ARBDB/gb_prot.h

@@ -24 +24 @@
 char *gb_destroy_main(GB_MAIN_TYPE *Main);
 GBDATA *gb_make_pre_defined_entry(GBCONTAINER *father, GBDATA *gbd, long index_pos, GBQUARK keyq);
-void gb_rename_entry(GBCONTAINER *gbc, const char *new_key);
 GBDATA *gb_make_entry(GBCONTAINER *father, const char *key, long index_pos, GBQUARK keyq, GB_TYPES type);
 GBCONTAINER *gb_make_pre_defined_container(GBCONTAINER *father, GBCONTAINER *gbd, long index_pos, GBQUARK keyq);

trunk/PERL_SCRIPTS/test/Makefile

@@ -12 +12 @@
 
 help:
-        test            test all perl scripts for syntax
+        @echo "test      tests all perl scripts for syntax"
 
 test: test.stamp

trunk/SOURCE_TOOLS/deadcode.pl

@@ -11 +11 @@
                       );
 
-my $reg_file_exclude = qr/\/(GDE|EISPACK|READSEQ)\//;
+my $reg_file_exclude = qr/\/(GDE|EISPACK|READSEQ|PERL2ARB)\//;