Changeset 8274

branches/e4fix/AISC_COM/AISC/aisc.pa

r7811	r8274
184	184	P #define AISC_GEN_SERVER_INCLUDED
185	185	--
186		~~P typedef int hash;~~
187	186	P typedef char *aisc_string;
188	187	P typedef const char *aisc_cstring;

branches/e4fix/AISC_COM/C/client.c

r7811	r8274
751	751	}
752	752
753		int aisc_put(aisc_com *link, int o_type, long object, ...)
754		{
755		// goes to header: __ATTR__SENTINEL
756		int mes_cnt, arg_cnt;
757		va_list parg;
758		int len;
759		arg_cnt = mes_cnt = 2;
	753	int aisc_put(aisc_com *link, int o_type, long object, ...) { // goes to header: __ATTR__SENTINEL
	754	int mes_cnt = 2;
760	755	link->aisc_mes_buffer[mes_cnt++] = object;
761	756	link->aisc_mes_buffer[mes_cnt++] = o_type;
762	757
	758	va_list parg;
763	759	va_start(parg, object);
764	760	if (!(mes_cnt = aisc_collect_sets(link, mes_cnt, parg, o_type, 4))) return 1;
…	…
767	763	link->aisc_mes_buffer[0] = mes_cnt - 2;
768	764	link->aisc_mes_buffer[1] = AISC_SET+link->magic;
769		len = aisc_c_write(link->socket, (const char )(link->aisc_mes_buffer), mes_cnt sizeof(long));
	765	int len = aisc_c_write(link->socket, (const char )(link->aisc_mes_buffer), mes_cnt sizeof(long));
770	766	if (!len) {
771	767	link->error = err_connection_problems;
…	…
779	775	}
780	776
781		int aisc_nput(aisc_com *link, int o_type, long object, ...)
782		{
783		// goes to header: __ATTR__SENTINEL
784		int mes_cnt, arg_cnt;
785		va_list parg;
786		int len;
787		arg_cnt = mes_cnt = 2;
	777	int aisc_nput(aisc_com *link, int o_type, long object, ...) { // goes to header: __ATTR__SENTINEL
	778	int mes_cnt = 2;
788	779	link->aisc_mes_buffer[mes_cnt++] = object;
789	780	link->aisc_mes_buffer[mes_cnt++] = o_type;
790	781
	782	va_list parg;
791	783	va_start(parg, object);
792	784	if (!(mes_cnt = aisc_collect_sets(link, mes_cnt, parg, o_type, 4))) {
…	…
797	789	link->aisc_mes_buffer[0] = mes_cnt - 2;
798	790	link->aisc_mes_buffer[1] = AISC_NSET+link->magic;
799		len = aisc_c_write(link->socket, (const char )(link->aisc_mes_buffer), mes_cnt sizeof(long));
	791	int len = aisc_c_write(link->socket, (const char )(link->aisc_mes_buffer), mes_cnt sizeof(long));
800	792	if (!len) {
801	793	link->error = err_connection_problems;

branches/e4fix/AISC_COM/C/server.c

r8104	r8274
433	433
434	434	Hs_struct open_aisc_server(const char path, int timeout, int fork) {
435		Hs_struct *hs;
	435	Hs_struct hs = (Hs_struct )calloc(sizeof(Hs_struct), 1);
	436	if (!hs) return 0;
	437
	438	hs->timeout = timeout;
	439	hs->fork = fork;
	440
436	441	static int so;
437		static int i;
438		const char *err;
439
440		hs = (Hs_struct *)calloc(sizeof(Hs_struct), 1);
441		if (!hs) return 0;
442		hs->timeout = timeout;
443		hs->fork = fork;
444		err = aisc_open_socket(path, TCP_NODELAY, 0, &so, &hs->unix_name);
	442	const char *err = aisc_open_socket(path, TCP_NODELAY, 0, &so, &hs->unix_name);
	443
445	444	if (err) {
446	445	if (*err) printf("Error in open_aisc_server: %s\n", err);
…	…
462	461	return NULL;
463	462	}
464		~~i = 0;~~
465	463	hs->hso = so;
466	464	return hs;
…	…
499	497	};
500	498
501		static long aisc_talking_get(long in_buf, int size, long out_buf, int max_size) {
502		long in_pos, out_pos;
503		long code, object_type, attribute, type;
504
505		aisc_talking_func_long function;
506		aisc_talking_func_long *functions;
507		aisc_talking_func_double dfunction;
508
509		long len;
510		long erg = 0;
511
512		double_xfer derg;
513		COMPILE_ASSERT(sizeof(derg.as_double) <= sizeof(derg.as_int));
514
515		long object;
516
517		in_pos = out_pos = 0;
	499	static long aisc_talking_get(long in_buf, int size, long out_buf, int) {
518	500	aisc_server_error = NULL;
519		object = in_buf[in_pos++];
520		object_type = (in_buf[in_pos] & AISC_OBJ_TYPE_MASK);
521		attribute = 0;
522		max_size = 0;
	501
	502	long in_pos = 0;
	503	long out_pos = 0;
	504	long object = in_buf[in_pos++];
	505	long object_type = (in_buf[in_pos] & AISC_OBJ_TYPE_MASK);
	506
523	507
524	508	if (object_type > (AISC_MAX_OBJECT*0x10000)) {
…	…
534	518	AISC_DUMP(aisc_talking_get, int, object_type);
535	519
	520	long attribute = 0;
	521	long erg = 0;
536	522	while (!aisc_server_error && (in_pos < size)) {
537		code = in_buf[in_pos];
538		attribute = code & AISC_ATTR_MASK;
539		type = code & AISC_VAR_TYPE_MASK;
540		functions = aisc_talking_functions_get[object_type];
	523	long code = in_buf[in_pos];
	524	long type = (code & AISC_VAR_TYPE_MASK);
	525	attribute = (code & AISC_ATTR_MASK);
	526
	527	aisc_talking_func_long *functions = aisc_talking_functions_get[object_type];
	528
541	529	if (!functions) {
542	530	aisc_server_error = "OBJECT HAS NO ATTRIBUTES";
…	…
550	538	break;
551	539	}
552		function = functions[attribute];
	540	aisc_talking_func_long function = functions[attribute];
553	541	if (!function) {
554	542	sprintf(error_buf, "DON'T KNOW ATTRIBUTE %li",
…	…
561	549	AISC_DUMP(aisc_talking_get, int, type);
562	550
	551	double_xfer derg;
	552	COMPILE_ASSERT(sizeof(derg.as_double) <= sizeof(derg.as_int));
	553
563	554	if (type == AISC_TYPE_DOUBLE) {
564		dfunction = (aisc_talking_func_double) function;
	555	aisc_talking_func_double dfunction = (aisc_talking_func_double) function;
565	556	derg.as_double = dfunction(object);
566	557	}
…	…
584	575	break;
585	576
586		case AISC_TYPE_STRING:
	577	case AISC_TYPE_STRING: {
587	578	if (!erg) erg = (long) "(null)";
588		len = strlen((char *)erg);
	579	long len = strlen((char *)erg);
589	580	if (len > AISC_MAX_STRING_LEN) {
590	581	erg = (long) "(string too long)";
…	…
601	592	out_pos += len;
602	593	break;
	594	}
603	595	case AISC_TYPE_BYTES:
604	596	{
…	…
785	777	}
786	778
787		static long aisc_talking_set(long in_buf, int size, long out_buf, int max_size) {
788		int in_pos, out_pos;
789		int object_type;
790		long object;
791		in_pos = out_pos = 0;
792		aisc_server_error = NULL;
793		max_size = 0;
794		object = in_buf[in_pos++];
795		object_type = ((int)in_buf[in_pos++]) & AISC_OBJ_TYPE_MASK;
796		return aisc_talking_sets(&(in_buf[in_pos]),
797		size-in_pos, out_buf, (long *)object, object_type);
798		}
799
800		static long aisc_talking_nset(long in_buf, int size, long out_buf, int max_size) {
801		int in_pos, out_pos;
802		long error;
803		int object_type;
804		long object;
805		in_pos = out_pos = 0;
806		aisc_server_error = NULL;
807		max_size = 0;
808		object = in_buf[in_pos++];
809		object_type = (int)(in_buf[in_pos++] & AISC_OBJ_TYPE_MASK);
810		error = aisc_talking_sets(&(in_buf[in_pos]),
811		size-in_pos, out_buf, (long *)object, object_type);
	779	static long aisc_talking_set(long in_buf, int size, long out_buf, int) {
	780	aisc_server_error = NULL;
	781
	782	int in_pos = 0;
	783	long object = in_buf[in_pos++];
	784	int object_type = ((int)in_buf[in_pos++]) & AISC_OBJ_TYPE_MASK;
	785
	786	return aisc_talking_sets(&(in_buf[in_pos]), size-in_pos, out_buf, (long *)object, object_type);
	787	}
	788
	789	static long aisc_talking_nset(long in_buf, int size, long out_buf, int) {
	790	aisc_server_error = NULL;
	791
	792	int in_pos = 0;
	793	long object = in_buf[in_pos++];
	794	int object_type = (int)(in_buf[in_pos++] & AISC_OBJ_TYPE_MASK);
	795
	796	aisc_talking_sets(&(in_buf[in_pos]), size-in_pos, out_buf, (long *)object, object_type);
812	797	return AISC_NO_ANSWER;
813	798	}
…	…
828	813	}
829	814
830		static long aisc_talking_create(long in_buf, int size, long out_buf, int max_size) {
831		int in_pos, out_pos;
832		long code, father_type, object_type, attribute, type;
833
834		aisc_talking_func_longp function;
835		aisc_talking_func_longp *functions;
836
837		int i;
	815	static long aisc_talking_create(long in_buf, int size, long out_buf, int) {
	816	aisc_server_error = NULL;
	817
	818	int in_pos = 0;
	819	long father_type = in_buf[in_pos++];
	820	long father = in_buf[in_pos++];
	821
838	822	long *erg = 0;
839		long father;
840
841		in_pos = out_pos = 0;
842		aisc_server_error = NULL;
843		father_type = in_buf[in_pos++];
844		father = in_buf[in_pos++];
845		max_size = 0;
846
847		for (i=0; i<1; i++) {
	823	for (int i=0; i<1; i++) {
848	824	if ((father_type&0xff00ffff) \|\|
849		(((unsigned int)father_type& 0xff0000) >= (AISC_MAX_OBJECT*0x10000))) {
	825	(((unsigned int)father_type& 0xff0000) >= (AISC_MAX_OBJECT*0x10000))) {
850	826	aisc_server_error = "AISC_CREATE_SERVER_ERROR: FATHER UNKNOWN";
851	827	break;
…	…
854	830	if (aisc_server_error) break;
855	831
856		father_type = father_type>>16;
857		functions = aisc_talking_functions_create[father_type];
858		code = in_buf[in_pos++];
859		attribute = code & AISC_ATTR_MASK;
860		type = code & AISC_VAR_TYPE_MASK;
861		object_type = in_buf[in_pos++];
	832	father_type = father_type>>16;
	833	aisc_talking_func_longp *functions = aisc_talking_functions_create[father_type];
	834
	835	long code = in_buf[in_pos++];
	836	long attribute = code & AISC_ATTR_MASK;
	837	long object_type = in_buf[in_pos++];
	838
862	839	if (!functions) {
863	840	sprintf(error_buf, "AISC_CREATE_SERVER_ERROR: FATHER %s DOESN'T HAVE TARGET-ATTRIBUTE %s",
…	…
870	847	break;
871	848	}
872		function = functions[attribute];
	849	aisc_talking_func_longp function = functions[attribute];
873	850	if (!function) {
874	851	sprintf(error_buf, "AISC_CREATE_SERVER_ERROR: FATHER %s FATHER DOESN'T HAVE TARGET-ATTRIBUTE %s",
…	…
894	871
895	872	static long aisc_talking_copy(long in_buf, int size, long out_buf, int max_size) {
896		~~int in_pos, out_pos~~;
897		int code, father_type, object_type, attribute, type;
898
899		~~aisc_talking_func_longp function~~;
900		~~aisc_talking_func_longp *functions~~;
901
902		int i;
	873	aisc_server_error = NULL;
	874
	875	int in_pos = 0;
	876	long object = in_buf[in_pos++];
	877	int father_type = (int)in_buf[in_pos++];
	878	long father = in_buf[in_pos++];
	879
903	880	long *erg = 0;
904		long father;
905		long object;
906
907		in_pos = out_pos = 0;
908		aisc_server_error = NULL;
909		object = in_buf[in_pos++];
910		father_type = (int)in_buf[in_pos++];
911		father = in_buf[in_pos++];
912
913		for (i=0; i<1; i++) {
	881	for (int i=0; i<1; i++) {
914	882	if ((father_type&0xff00ffff) \|\|
915	883	(((unsigned int)father_type& 0xff0000) >= (AISC_MAX_OBJECT*0x10000))) {
…	…
920	888	if (aisc_server_error) break;
921	889
922		father_type = father_type>>16;
923		functions = aisc_talking_functions_copy[father_type];
924		code = (int)in_buf[in_pos++];
925		object_type = (int)in_buf[in_pos++];
926
927		attribute = code & AISC_ATTR_MASK;
928		type = code & AISC_VAR_TYPE_MASK;
	890	father_type = father_type>>16;
	891	aisc_talking_func_longp *functions = aisc_talking_functions_copy[father_type];
929	892
930	893	if (!functions) {
…	…
932	895	break;
933	896	}
	897
	898	int code = (int)in_buf[in_pos++];
	899	int object_type = (int)in_buf[in_pos++];
	900	int attribute = code & AISC_ATTR_MASK;
	901
934	902	if (attribute > AISC_MAX_ATTR) {
935	903	aisc_server_error = "AISC_COPY_SERVER_ERROR: UNKNOWN ATTRIBUTE";
936	904	break;
937	905	}
938		function = functions[attribute];
	906	aisc_talking_func_longp function = functions[attribute];
939	907	if (!function) {
940	908	sprintf(error_buf, "AISC_COPY_SERVER_ERROR: FATHER %s DOESN'T HAVE TARGET-ATTRIBUTE %s",
…	…
963	931	}
964	932
965		static long aisc_talking_find(long in_buf, int size, long out_buf, int max_size) {
966		int in_pos, out_pos;
967		long code, father_type, attribute, type;
968
969		aisc_talking_func_longp function;
970		aisc_talking_func_longp *functions;
971
972		int i;
	933	static long aisc_talking_find(long in_buf, int /size/, long out_buf, int /max_size/) {
	934	aisc_server_error = NULL;
	935
	936	int in_pos = 0;
	937	long father_type = in_buf[in_pos++];
	938	long father = in_buf[in_pos++];
	939
973	940	long *erg = 0;
974		long father;
975
976		in_pos = out_pos = 0;
977		aisc_server_error = NULL;
978		father_type = in_buf[in_pos++];
979		father = in_buf[in_pos++];
980		size = size;
981		max_size = max_size;
982
983		for (i = 0; i < 1; i++) {
	941	for (int i = 0; i < 1; i++) {
984	942	if ((father_type & 0xff00ffff) \|\|
985	943	(((unsigned int) father_type & 0xff0000) >= (AISC_MAX_OBJECT*0x10000))) {
…	…
992	950
993	951	father_type = father_type>>16;
994		functions = aisc_talking_functions_find[father_type];
995		code = in_buf[in_pos++];
996
997		attribute = code & AISC_ATTR_MASK;
998		type = code & AISC_VAR_TYPE_MASK;
	952	aisc_talking_func_longp *functions = aisc_talking_functions_find[father_type];
	953
	954	long code = in_buf[in_pos++];
	955	long attribute = code & AISC_ATTR_MASK;
999	956
1000	957	if (!functions) {
…	…
1006	963	break;
1007	964	}
1008		function = functions[attribute];
	965	aisc_talking_func_longp function = functions[attribute];
1009	966	if (!function) {
1010	967	sprintf(error_buf, "AISC_FIND_SERVER_ERROR: FATHER %s DON'T KNOW ATTRIBUTE %s FOR SEARCH",

branches/e4fix/AISC_MKPTPS/Makefile

r8223	r8274
9	9
10	10	$(BINARY): $(OBJECTS)
11		$(LINK_EXECUTABLE) $@ $(OBJECTS) $(EXECLIBS)
	11	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(OBJECTS) $(EXECLIBS)
12	12
13	13	.cxx.o:

branches/e4fix/AISC_MKPTPS/mkptypes.cxx

r8102	r8274
79	79	static int glastc = ' '; // last char. seen by getsym()
80	80
81		static char *current_file = 0; // name of current file
82		static char *current_dir = 0; // name of current directory
83		static c~~har *header_comment = 0;~~ // comment written into header
84		static long ~~linenum = 1L;~~ // line number in current file
	81	static char *current_file = 0; // name of current file
	82	static char *current_dir = 0; // name of current directory
	83	static const char *header_comment = 0; // comment written into header
	84	static long linenum = 1L; // line number in current file
85	85
86	86	static char const *macro_name = "P_"; // macro to use for prototypes
…	…
533	533	};
534	534
535		~~static AttributeParser attribute_parser("__attribute__", false, true);~~
536		~~static AttributeParser ATTR_parser("__ATTR__", true, false);~~
537
538	535	static void search_comment_for_attribute() {
539	536	if (found__attribute__ \|\| found__ATTR__) return; // only parse once (until reset)
540	537	last_comment[lc_size] = 0; // close string
	538
	539	static AttributeParser attribute_parser("__attribute__", false, true);
	540	static AttributeParser ATTR_parser("__ATTR__", true, false);
541	541
542	542	char *seen_attribute = attribute_parser.parse(last_comment, lc_size);
…	…
1480	1480	}
1481	1481
1482		int ~~main(int argc, char **argv~~) {
	1482	int ARB_main(int argc, const char *argv[]) {
1483	1483	FILE *f;
1484		char t, iobuf;
	1484	const char *t;
	1485	char *iobuf;
1485	1486	int exit_if_noargs = 0;
1486	1487

branches/e4fix/ARBDB/adGene.cxx

r7814	r8274
952	952
953	953	pos->stop_pos[2] = 26;
954		TEST_WRITE_GEN_POSITION_ERROR(pos, NULL);
	954	TEST_WRITE_GEN_POSITION_ERROR(pos, (void*)NULL);
955	955
956	956	pos->stop_pos[0] = 100;

branches/e4fix/ARBDB/adTest.cxx

r7246	r8274
10	10
11	11	#include "gb_storage.h"
12
13		~~#define VERBOSE 0~~
14
15		~~static const char *actType = "none";~~
16		~~static void *actData = NULL;~~
17		~~static GBQUARK actQuark = 0;~~
18
19		~~#define err(gbd, quark, type, mess) \~~
20		~~do { \~~
21		~~fprintf(stderr, "(%s)0x%p(=%s) %s (in (%s)0x%p(=%s))\n", \~~
22		~~type, gbd, Main->keys[quark].key, mess, \~~
23		~~actType, actData, Main->keys[actQuark].key); \~~
24		~~err=1; \~~
25		~~} while (0)~~
26
27		~~#define errGBD(gbd, quark, mess) err(gbd, quark, "GBDATA", mess)~~
28		~~#define errGBC(gbc, quark, mess) err(gbc, quark, "GBCONTAINER", mess)~~
29
30		~~void testData(GB_MAIN_TYPE Main, GBDATA gbd, long server_id, GBQUARK key_quark)~~
31		{
32		~~int err = 0;~~
33
34		~~#if (VERBOSE>=2)~~
35		~~printf("Teste (GBDATA*)0x%p (=%s)\n", gbd, Main->keys[key_quark].key);~~
36		~~#endif~~
37
38		~~if (gbd->server_id != server_id) errGBD(gbd, key_quark, "illegal server id");~~
39		}
40
41		~~void testContainer(GB_MAIN_TYPE Main, GBCONTAINER gbc, long server_id, GBQUARK key_quark) {~~
42		~~gb_header_list *header;~~
43		~~int item;~~
44		~~int err = 0;~~
45		~~const char *oldType = actType;~~
46		~~void *oldData = actData;~~
47		~~GBQUARK oldQuark = actQuark;~~
48
49		~~#if (VERBOSE>=1)~~
50		~~printf("Teste (GBCONTAINER*)0x%p (=%s)\n", gbc, Main->keys[key_quark].key);~~
51		~~#endif~~
52		~~actType = "GBCONTAINER";~~
53		~~actData = gbc;~~
54		~~actQuark = key_quark;~~
55
56		~~if (gbc->server_id != server_id) {~~
57		~~errGBC(gbc, actQuark, "illegal server id");~~
58		}
59
60		~~header = GB_DATA_LIST_HEADER(gbc->d);~~
61		~~for (item=0; item<gbc->d.nheader; item++) {~~
62		~~GBDATA *gbd = GB_HEADER_LIST_GBD(header[item]);~~
63		~~GBCONTAINER *father;~~
64		~~int type;~~
65		~~GBQUARK quark = header[item].flags.key_quark;~~
66
67		~~if (!gbd) continue;~~
68
69		~~if (quark>=Main->sizeofkeys) {~~
70		~~fprintf(stderr, "Illegal quark %i\n", quark);~~
71		~~continue;~~
72		}
73
74
75		~~if (!gbd) errGBC(gbc, key_quark, "NULL-GBDATA in header-list");~~
76
77		~~type = GB_TYPE(gbd);~~
78
79		~~if (type==GB_DB) testContainer(Main, (GBCONTAINER*)gbd, server_id, quark);~~
80		~~else testData(Main, gbd, server_id, quark);~~
81
82		~~father = GB_FATHER(gbd);~~
83		~~if (!father) {~~
84		~~errGBD(gbd, quark, "has no father.");~~
85		}
86		~~else if (father!=gbc) {~~
87		~~errGBD(gbd, quark, "is not son of..");~~
88		}
89		~~else if (gbd->index!=item) {~~
90		~~errGBD(gbd, quark, "index mismatch..");~~
91		}
92		~~else if (err) {~~
93		~~errGBD(gbd, quark, "is correct connected to..");~~
94		}
95		}
96
97		~~actType = oldType;~~
98		~~actData = oldData;~~
99		~~actQuark = oldQuark;~~
100		}
101
102		~~void gb_testDB(GBDATA *gbd)~~
103		{
104		~~GB_MAIN_TYPE *Main = 0;~~
105		~~GBCONTAINER *gbc;~~
106		~~long server_id;~~
107		~~int err=0;~~
108
109		~~actType = "GB_MAIN_TYPE";~~
110		~~actData = gbd;~~
111		~~actQuark = 0;~~
112
113		~~gbc = GB_FATHER(gbd);~~
114		~~Main = GBCONTAINER_MAIN(gbc);~~
115
116		~~if (!gbc) {~~
117		~~fprintf(stderr, "(GBDATA*)0x%p has no father\n", gbd);~~
118		}
119		~~if (!Main) {~~
120		~~fprintf(stderr, "(GBCONTAINER*)0x%p has no main-entry\n", gbc);~~
121		}
122
123		~~gbc = Main->data;~~
124		~~if (!gbc) {~~
125		~~err(Main, actQuark, "GB_MAIN_TYPE", "has no data");~~
126		}
127
128		~~server_id = gbc->server_id;~~
129
130		~~if (GB_FATHER(gbc)!=Main->dummy_father) {~~
131		~~errGBC(gbc, actQuark, "mainContainer's father != dummy_father");~~
132		}
133		~~if (Main->dummy_father->server_id != server_id) {~~
134		~~errGBC(Main->dummy_father, actQuark, "illegal server id");~~
135		}
136
137		~~if (!err) testContainer(Main, gbc, server_id, 0);~~
138
139		~~printf("testDB passed.\n");~~
140		}
141	12
142	13	const char GB_get_type_name(GBDATA gbd) {

branches/e4fix/ARBDB/ad_prot.h

r8103	r8274
115	115	const char GBS_regmatch(const char str, const char regExpr, size_t matchlen, GB_ERROR *error);
116	116	char GBS_regreplace(const char str, const char regReplExpr, GB_ERROR error);
117		GB_CSTR GBS_find_string(GB_CSTR ~~str~~, GB_CSTR substr, int match_mode);
	117	GB_CSTR GBS_find_string(GB_CSTR cont, GB_CSTR substr, int match_mode);
118	118	bool GBS_string_matches(const char str, const char search, GB_CASE case_sens);
119	119	bool GBS_string_matches_regexp(const char str, const GBS_string_matcher expr);

branches/e4fix/ARBDB/adcomm.cxx

r8103	r8274
609	609
610	610	static GBCM_ServerResult gbcms_write_updated(int socket, GBDATA gbd, long hsin, long client_clock, long buffer) {
611		gb_server_data *hs;
612		int send_header = 0;
	611	int send_header = 0;
613	612
614	613	if (GB_GET_EXT_UPDATE_DATE(gbd)<=client_clock) return GBCM_SERVER_OK;
615		~~hs = (gb_server_data *)hsin;~~
616	614	if (GB_GET_EXT_CREATION_DATE(gbd) > client_clock) {
617	615	buffer[0] = GBCM_COMMAND_PUT_UPDATE_CREATE;
…	…
806	804	Socinf si = (Socinf )sin;
807	805	long anz;
808		~~long *buffer;~~
809	806	char *user;
810	807	fd_set set;
…	…
838	835	gbcm_write_flush(socket);
839	836	// send modified data to client
840		~~buffer = (long *)GB_give_buffer(1024);~~
841	837
842	838	GB_begin_transaction(gbd);

branches/e4fix/ARBDB/adfile.cxx

r8103	r8274
701	701	void TEST_find_file() {
702	702	TEST_ASSERT_EQUAL(GB_existing_file("min_ascii.arb", false), "min_ascii.arb");
703		TEST_ASSERT_~~EQUAL(GB_existing_file("nosuchfile", false), NULL~~);
	703	TEST_ASSERT_NULL(GB_existing_file("nosuchfile", false));
704	704
705	705	char *tcporg = GB_lib_file(false, "", "arb_tcp_org.dat");
706	706	TEST_ASSERT_EQUAL(tcporg, GB_path_in_ARBHOME("lib/arb_tcp_org.dat"));
707		TEST_ASSERT_~~EQUAL(GB_lib_file(true, "bla", "blub"), NULL~~);
	707	TEST_ASSERT_NULL(GB_lib_file(true, "bla", "blub"));
708	708	free(tcporg);
709	709
710	710	char *status = GB_property_file(false, "status.arb");
711	711	TEST_ASSERT_EQUAL(status, GB_path_in_ARBHOME("lib/arb_default/status.arb"));
712		TEST_ASSERT_~~EQUAL(GB_property_file(true, "undhepp"), NULL~~);
	712	TEST_ASSERT_NULL(GB_property_file(true, "undhepp"));
713	713	free(status);
714	714	}
…	…
720	720	#endif
721	721
722		~~#if defined(DEVEL_RALF)~~
723	722	// gcc reports: "warning: logical 'or' of collectively exhaustive tests is always true"
724	723	// for 'implicated(any, any)'. True, obviously. Nevertheless annoying.
725	724	#pragma GCC diagnostic ignored "-Wlogical-op"
726		~~#endif~~
727	725
728	726	void TEST_logic() {

branches/e4fix/ARBDB/admatch.cxx

r7931	r8274
323	323	// wildcard search
324	324
325		GB_CSTR GBS_find_string(GB_CSTR ~~str~~, GB_CSTR substr, int match_mode) {
	325	GB_CSTR GBS_find_string(GB_CSTR cont, GB_CSTR substr, int match_mode) {
326	326	/* search a substring in another string
327	327	* match_mode == 0 -> exact match
…	…
336	336
337	337	case 0: // exact match
338		for (p1 = ~~str~~, p2 = substr; *p1;) {
	338	for (p1 = cont, p2 = substr; *p1;) {
339	339	if (!(b = *p2)) {
340		return (char *)~~str~~;
	340	return (char *)cont;
341	341	}
342	342	else {
…	…
347	347	else {
348	348	p2 = substr;
349		p1 = (++~~str~~);
350		}
351		}
352		}
353		if (!p2) return (char )~~str~~;
	349	p1 = (++cont);
	350	}
	351	}
	352	}
	353	if (!p2) return (char )cont;
354	354	break;
355	355
356	356	case 1: // a==A
357		for (p1 = ~~str~~, p2 = substr; *p1;) {
	357	for (p1 = cont, p2 = substr; *p1;) {
358	358	if (!(b = *p2)) {
359		return (char *)~~str~~;
	359	return (char *)cont;
360	360	}
361	361	else {
…	…
366	366	else {
367	367	p2 = substr;
368		p1 = (++~~str~~);
369		}
370		}
371		}
372		if (!p2) return (char )~~str~~;
	368	p1 = (++cont);
	369	}
	370	}
	371	}
	372	if (!p2) return (char )cont;
373	373	break;
374	374	case 2: // a==a && a==?
375		for (p1 = ~~str~~, p2 = substr; *p1;) {
	375	for (p1 = cont, p2 = substr; *p1;) {
376	376	if (!(b = *p2)) {
377		return (char *)~~str~~;
	377	return (char *)cont;
378	378	}
379	379	else {
…	…
384	384	else {
385	385	p2 = substr;
386		p1 = (++~~str~~);
387		}
388		}
389		}
390		if (!p2) return (char )~~str~~;
	386	p1 = (++cont);
	387	}
	388	}
	389	}
	390	if (!p2) return (char )cont;
391	391	break;
392	392
393	393	default: // a==A && a==?
394		for (p1 = ~~str~~, p2 = substr; *p1;) {
	394	for (p1 = cont, p2 = substr; *p1;) {
395	395	if (!(b = *p2)) {
396		return (char *)~~str~~;
	396	return (char *)cont;
397	397	}
398	398	else {
…	…
403	403	else {
404	404	p2 = substr;
405		p1 = (++~~str~~);
406		}
407		}
408		}
409		if (!p2) return (char )~~str~~;
	405	p1 = (++cont);
	406	}
	407	}
	408	}
	409	if (!p2) return (char )cont;
410	410	break;
411	411	}

branches/e4fix/ARBDB/adquery.cxx

r7407	r8274
869	869	*/
870	870	int strmalloc = 0;
871		~~int len;~~
872	871	char *buffer;
873	872	GB_ERROR error;
…	…
934	933
935	934	gb_local->gbl.gb_main = gb_main;
936		~~len = strlen(commands)+1;~~
937	935	buffer = strdup(commands);
938	936

branches/e4fix/ARBDB/arbdb.cxx

r8100	r8274
2573	2573
2574	2574	static void gb_remove_callback(GBDATA gbd, GB_CB_TYPE type, GB_CB func, int clientdata, bool cd_should_match) {
2575		~~bool removed = false;~~
2576	2575	bool exactly_one = cd_should_match; // remove exactly one callback
2577	2576
…	…
2605	2604	*cb_ptr = cb->next;
2606	2605	gbm_free_mem(cb, sizeof(gb_callback), GB_GBM_INDEX(gbd));
2607		~~removed = true;~~
2608	2606	if (exactly_one) break;
2609	2607	}

branches/e4fix/ARBDB/arbdb.h

r8100	r8274
156	156	// const wrappers for functions from ad_prot.h
157	157
158		inline char GBS_find_string(char ~~str~~, GB_CSTR key, int match_mode) {
159		return const_cast<char*>(GBS_find_string(const_cast<GB_CSTR>(~~str~~), key, match_mode));
	158	inline char GBS_find_string(char content, GB_CSTR key, int match_mode) {
	159	return const_cast<char*>(GBS_find_string(const_cast<GB_CSTR>(content), key, match_mode));
160	160	}
161	161

branches/e4fix/ARBDB/gb_prot.h

r8037	r8274
13	13	#endif
14	14
15
16		~~/* adTest.cxx */~~
17		~~void gb_testDB(GBDATA *gbd);~~
18	15
19	16	/* ad_load.cxx */

branches/e4fix/ARB_GDE/GDE_FileIO.cxx

r7811	r8274
103	103
104	104
105		static void ReadNA_Flat(char filename, char dataset, int type)
106		{
	105	static void ReadNA_Flat(char filename, char dataset) {
107	106	size_t j;
108		int ~~i, jj, c~~, curelem=0, offset;
	107	int jj, curelem=0, offset;
109	108	char buffer[GBUFSIZ];
110	109	char in_line[GBUFSIZ];
111		~~char curname[GBUFSIZ];~~
112		~~i=0; c=0; type=0;~~
113	110
114	111	NA_Sequence *this_elem;
…	…
117	114	FILE *file;
118	115
119		~~curname[0] = '\0';~~
120	116	data = (NA_Alignment*)dataset;
121	117
…	…
226	222	{
227	223	case NA_FLAT:
228		ReadNA_Flat(filename, (char*)dataset~~, type~~);
	224	ReadNA_Flat(filename, (char*)dataset);
229	225	((NA_Alignment*)dataset)->format = GDE;
230	226	break;
231	227
232	228	case GENBANK:
233		ReadGen(filename, dataset~~, type~~);
	229	ReadGen(filename, dataset);
234	230	((NA_Alignment*)dataset)->format = GENBANK;
235	231	break;
…	…
241	237
242	238	case GDE:
243		ReadGDE(filename, dataset~~, type~~);
	239	ReadGDE(filename, dataset);
244	240	((NA_Alignment*)dataset)->format = GDE;
245	241	break;
…	…
388	384	{
389	385	int curlen=0, j;
390		~~NA_Base *temp;~~
391		~~temp=0;~~
392	386	if (seq->seqlen+len >= seq->seqmaxlen)
393	387	{
…	…
660	654	size_t j;
661	655	size_t curlen = 0;
662		int *colors = 0, ~~orig_ctype,~~ jj, indx = 0;
	656	int *colors = 0, jj, indx = 0;
663	657	FILE *file;
664	658
…	…
668	662
669	663	curname[0] = '\0';
670		~~orig_ctype = COLOR_MONO;~~
671	664	file = fopen(filename, "r");
672	665	if (file == NULL)
…	…
795	788
796	789
797		int WriteStatus(NA_Alignment aln, char filename, int method)
798		{
	790	int WriteStatus(NA_Alignment aln, char filename) {
799	791	NA_Sequence *this_seq;
800	792	int j;
801	793	FILE *file;
802		~~method=0;~~ filename=0;
	794	filename=0;
803	795
804	796	if (DataSet == NULL)
…	…
853	845	void NormalizeOffset(NA_Alignment *aln)
854	846	{
855		~~int i;~~
856	847	size_t j;
857	848	int offset = INT_MAX;
858		~~i=0;~~
859	849
860	850	for (j=0; j<aln->numelements; j++)

branches/e4fix/ARB_GDE/GDE_Genbank.cxx

r7812	r8274
63	63	// ENDARB
64	64
65		void ReadGen(char filename, NA_Alignment dataset, int type)
66		{
	65	void ReadGen(char filename, NA_Alignment dataset) {
67	66	int done = FALSE;
68	67	size_t len = 0;
69	68	size_t j = 0;
70		int ~~count,~~ IS_REALLY_AA = FALSE;
	69	int IS_REALLY_AA = FALSE;
71	70	char in_line[GBUFSIZ], c;
72	71	char buffer = 0, gencomments = NULL, fields[8][GBUFSIZ];
…	…
74	73	int genclen = 0, curelem = 0, n = 0;
75	74	int start_col = -1;
76
77		~~type=0; count=0;~~
78	75
79	76	NA_Sequence *this_elem = 0;

branches/e4fix/ARB_GDE/GDE_HGLfile.cxx

r7140	r8274
47	47	}
48	48
49		static void StripSpecial(char *string)
50		{
51		int i, j, len;
52		i=0;
	49	static void StripSpecial(char *string) {
	50	int j, len;
53	51
54	52	len = strlen(string);
…	…
171	169	}
172	170
173		void ReadGDE(char filename, NA_Alignment dataset, int type)
174		{
	171	void ReadGDE(char filename, NA_Alignment dataset) {
175	172	int done = FALSE;
176	173	size_t len = 0, j=0;
177		int success, ~~count,~~ temp = 0;
178		char in_line[GBUFSIZ]~~, c~~;
	174	int success, temp = 0;
	175	char in_line[GBUFSIZ];
179	176	char buffer, line;
180	177	size_t buflen = GBUFSIZ;
181		int ~~genclen = 0,~~ curelem = 0;
	178	int curelem = 0;
182	179	NA_Sequence *this_elem = NULL, temp_elem;
183	180	FILE *file;
184
185		~~type=0; count=0; c=0;~~
186	181
187	182	ErrorOut5(0!=(file = fopen(filename, "r")), "No such file");
…	…
476	471	PROT_WHITE_SPACE+
477	472	PROT_TRANSLATION;
478		~~genclen = 0;~~
479	473
480	474	// Make a new sequence entry...

branches/e4fix/ARB_GDE/GDE_event.cxx

r7811	r8274
545	545	case GENBANK: WriteGen (DataSet, gfile.name, select_mode, gfile.maskable); break;
546	546	case NA_FLAT: WriteNA_Flat(DataSet, gfile.name, select_mode, gfile.maskable); break;
547		case STATUS_FILE: WriteStatus (DataSet, gfile.name~~, select_mode~~); break;
	547	case STATUS_FILE: WriteStatus (DataSet, gfile.name); break;
548	548	case GDE: WriteGDE (DataSet, gfile.name, select_mode, gfile.maskable); break;
549	549	default: break;

branches/e4fix/ARB_GDE/GDE_proto.h

r7121	r8274
38	38	void InitNASeq(NA_Sequence *seq, int type);
39	39	void ReadCMask(const char *filename);
40		int WriteStatus(NA_Alignment aln, char filename~~, int method~~);
	40	int WriteStatus(NA_Alignment aln, char filename);
41	41	void NormalizeOffset(NA_Alignment *aln);
42	42	int WriteCMask(NA_Alignment aln, char filename, int method, int maskable);
43	43
44	44	/* GDE_Genbank.cxx */
45		void ReadGen(char filename, NA_Alignment dataset~~, int type~~);
	45	void ReadGen(char filename, NA_Alignment dataset);
46	46	int WriteGen(NA_Alignment aln, char filename, int method, int maskable);
47	47	void SetTime(void *b);
48	48
49	49	/* GDE_HGLfile.cxx */
50		void ReadGDE(char filename, NA_Alignment dataset~~, int type~~);
	50	void ReadGDE(char filename, NA_Alignment dataset);
51	51	int WriteGDE(NA_Alignment aln, char filename, int method, int maskable);
52	52	void SeqNorm(NA_Sequence *seq);

branches/e4fix/AWT/AWT_canvas.cxx

r7811	r8274
97	97	AW_device_size *size_device = aww->get_size_device(AW_MIDDLE_AREA);
98	98
99		size_device->set_filter(AW_SIZE\|~~AW_SIZE_UNSCALED~~);
	99	size_device->set_filter(AW_SIZE\|(consider_text_for_size ? AW_SIZE_UNSCALED : 0));
100	100	size_device->reset();
101	101
102	102	tree_disp->show(size_device);
103		tree_disp->exports.set_extra_text_padding(size_device->get_unscaleable_overlap());
	103
	104	if (consider_text_for_size) {
	105	tree_disp->exports.set_extra_text_padding(size_device->get_unscaleable_overlap());
	106	}
104	107
105	108	size_device->get_size_information(&(this->worldinfo));
…	…
717	720
718	721	AWT_canvas::AWT_canvas(GBDATA gb_maini, AW_window awwi, AWT_graphic awd, AW_gc_manager &set_gc_manager, const char user_awari)
719		: user_awar(strdup(user_awari))
	722	: consider_text_for_size(true)
	723	, user_awar(strdup(user_awari))
720	724	, shift_x_to_fit(0)
721	725	, shift_y_to_fit(0)

branches/e4fix/AWT/awt_canvas.hxx

r7812	r8274
160	160
161	161	class AWT_canvas : virtual Noncopyable {
	162	bool consider_text_for_size;
	163
162	164	public:
163	165	// too many callbacks -> public
…	…
218	220	void zoom_reset_and_refresh() { zoom_reset(); refresh(); }
219	221
	222	void set_consider_text_for_zoom_reset(bool consider) { consider_text_for_size = consider; }
	223
220	224	void refresh_by_exports() { tree_disp->refresh_by_exports(this); }
221	225

branches/e4fix/CONVERTALN/main.cxx

r7200	r8274
215	215	return strcmp(arg, "-h") == 0 \|\| strcmp(arg, "--help") == 0;
216	216	}
217		static bool command_line_conversion(int argc, char** argv, FormattedFile& in, FormattedFile& out) {
	217	static bool command_line_conversion(int argc, const char * const *argv, FormattedFile& in, FormattedFile& out) {
218	218	for (int c = 1; c<argc; c++) {
219	219	if (is_help_req(argv[c])) {
…	…
244	244	}
245	245
246		int ~~main(int argc,~~ char *argv[]) {
	246	int ARB_main(int argc, const char *argv[]) {
247	247	int exitcode = EXIT_SUCCESS;
248	248	try {

branches/e4fix/CONVERTALN/prototypes.h

r7187	r8274
63	63
64	64	/* main.cxx */
	65	int ARB_main(int argc, const char *argv[]);
65	66
66	67	/* mg.cxx */

branches/e4fix/CORE/arb_string.cxx

r8223	r8274
248	248
249	249	char *null = NULL;
250		TEST_ASSERT_NULL(NULL);
	250	TEST_ASSERT_NULL((void*)NULL);
251	251	TEST_ASSERT_NULL(null);
252	252

branches/e4fix/DBSERVER/db_server.cxx

r8103	r8274
249	249	}
250	250
251		int ~~main(int argc, char **argv~~) {
252		arb_params *params = arb_trace_argv(&argc, argv);
	251	int ARB_main(int argc, const char *argv[]) {
	252	arb_params params = arb_trace_argv(&argc, (const char *)argv);
253	253
254	254	bool help = false;

branches/e4fix/DIST/DI_main.cxx

r8036	r8274
42	42	}
43	43
44		int ~~main(int argc, char **argv~~) {
	44	int ARB_main(int argc, const char *argv[]) {
45	45	if (argc >= 2 && strcmp(argv[1], "--help") == 0) {
46	46	fprintf(stderr,
…	…
57	57
58	58	{
59		arb_params *params = arb_trace_argv(&argc, argv);
	59	arb_params params = arb_trace_argv(&argc, (const char *)argv);
60	60	if (argc==2) {
61	61	freedup(params->db_server, argv[1]);
…	…
87	87	aw_root->add_timed_callback(2000, DI_timer, AW_CL(GLOBAL_gb_main), 0);
88	88	aw_root->main_loop();
	89
	90	return EXIT_SUCCESS;
89	91	}
90	92

branches/e4fix/DIST/DI_matr.cxx

r8098	r8274
1348	1348	progress.subtitle("Search Correction");
1349	1349
1350		~~DI_TRANSFORMATION trans;~~
1351		~~trans = (DI_TRANSFORMATION)aw_root->awar(AWAR_DIST_CORR_TRANS)->read_int();~~
1352
1353	1350	phm->analyse();
1354	1351	delete phm;

branches/e4fix/DIST/Makefile

r7916	r8274
10	10	DI_main.o \
11	11	DI_matr.o \
12		~~DI_mldist.o \~~
13	12	DI_protdist.o \
14	13	DI_save_matr.o \
…	…
237	236	DI_matr.o: $(ARBHOME)/INCLUDE/test_global.h
238	237
239		~~DI_mldist.o: di_matr.hxx~~
240		~~DI_mldist.o: di_mldist.hxx~~
241		~~DI_mldist.o: $(ARBHOME)/INCLUDE/ad_prot.h~~
242		~~DI_mldist.o: $(ARBHOME)/INCLUDE/ad_t_prot.h~~
243		~~DI_mldist.o: $(ARBHOME)/INCLUDE/AliView.hxx~~
244		~~DI_mldist.o: $(ARBHOME)/INCLUDE/AP_matrix.hxx~~
245		~~DI_mldist.o: $(ARBHOME)/INCLUDE/AP_pro_a_nucs.hxx~~
246		~~DI_mldist.o: $(ARBHOME)/INCLUDE/AP_seq_simple_pro.hxx~~
247		~~DI_mldist.o: $(ARBHOME)/INCLUDE/AP_sequence.hxx~~
248		~~DI_mldist.o: $(ARBHOME)/INCLUDE/AP_Tree.hxx~~
249		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arb_assert.h~~
250		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arb_core.h~~
251		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arb_error.h~~
252		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arb_msg.h~~
253		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arb_progress.h~~
254		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arb_string.h~~
255		~~DI_mldist.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx~~
256		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arbdb.h~~
257		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arbdb_base.h~~
258		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arbdbt.h~~
259		~~DI_mldist.o: $(ARBHOME)/INCLUDE/arbtools.h~~
260		~~DI_mldist.o: $(ARBHOME)/INCLUDE/attributes.h~~
261		~~DI_mldist.o: $(ARBHOME)/INCLUDE/aw_base.hxx~~
262		~~DI_mldist.o: $(ARBHOME)/INCLUDE/aw_color_groups.hxx~~
263		~~DI_mldist.o: $(ARBHOME)/INCLUDE/aw_msg.hxx~~
264		~~DI_mldist.o: $(ARBHOME)/INCLUDE/downcast.h~~
265		~~DI_mldist.o: $(ARBHOME)/INCLUDE/dupstr.h~~
266		~~DI_mldist.o: $(ARBHOME)/INCLUDE/smartptr.h~~
267		~~DI_mldist.o: $(ARBHOME)/INCLUDE/test_global.h~~
268
269	238	DI_protdist.o: di_matr.hxx
270	239	DI_protdist.o: di_protdist.hxx

branches/e4fix/DIST/distanalyse.cxx

r6867	r8274
21	21
22	22	long act_gci, mean_gci=0;
23		float act_gc, m~~ean_gc, m~~in_gc=9999.9, max_gc=0.0;
	23	float act_gc, min_gc=9999.9, max_gc=0.0;
24	24	long act_len, mean_len=0, min_len=9999999, max_len=0;
25	25
…	…
63	63	" this kind of \"error\"");
64	64	}
65		~~mean_gc = ((float) mean_gci) / mean_len / nentries;~~
66	65	mean_len /= nentries;
67	66

branches/e4fix/DIST/needs_libs

r6865	r8274
7	7	SL/MATRIX/MATRIX.a
8	8	SL/NEIGHBOURJOIN/NEIGHBOURJOIN.a
	9	SL/NDS/NDS.a
9	10

branches/e4fix/EDIT4

Property svn:mergeinfo set to /branches/dev_elmar/EDIT4:7699-8224

branches/e4fix/EDIT4/ED4_base.cxx

r8236	r8274
1204	1204
1205	1205	ED4_multi_species_manager *multi_species_manager = NULL;
1206
1207
1208		~~#if defined(LIMIT_TOP_AREA_SPACE)~~
1209		~~int nr_of_visible_species = 0;~~
1210		~~int nr_of_children_in_group = 0;~~
1211		~~ED4_AREA_LEVEL level = temp_parent->get_area_level(&multi_species_manager);~~
1212		~~if (level==ED4_A_TOP_AREA \|\| level==ED4_A_BOTTOM_AREA) { // check if there are any unfolding restrictions~~
1213		~~nr_of_visible_species = multi_species_manager->count_visible_children();~~
1214
1215		~~if (nr_of_visible_species >= MAX_TOP_AREA_SIZE) {~~
1216		~~aw_message("Top area limited to " MAX_TOP_AREA_SIZE " species\n"~~
1217		~~"Advice: Move group to main area and try again");~~
1218		~~return ED4_R_IMPOSSIBLE;~~
1219		}
1220
1221		~~nr_of_children_in_group = temp_parent->get_defined_level(ED4_L_MULTI_SPECIES)->to_multi_species_manager()->count_visible_children();~~
1222
1223		~~if (nr_of_children_in_group + nr_of_visible_species - 1 > MAX_TOP_AREA_SIZE) {~~
1224		~~aw_message("Top area limited to " MAX_TOP_AREA_SIZE " species\n"~~
1225		~~"Advice: Move group to main area and try again");~~
1226		~~return ED4_R_IMPOSSIBLE;~~
1227		}
1228		}
1229		~~#else // LIMIT_TOP_AREA_SPACE~~
1230	1206	temp_parent->get_area_level(&multi_species_manager);
1231		~~#endif~~
1232	1207
1233	1208	for (i=0; i < temp_parent->children->members(); i++) {

branches/e4fix/EDIT4/ED4_block.cxx

r8201	r8274
166	166
167	167	void ED4_with_whole_block(ED4_blockoperation block_operation, int repeat) {
168		GB_ERROR error = GB_begin_transaction(GLOBAL_gb_main);
169		ED4_sequence_terminal *err_term = 0;
170		ED4_cursor *cursor = &current_cursor();
171		int base_pos = (cursor && cursor->owner_of_cursor != 0) ? cursor->get_base_position() : -1;
	168	GB_ERROR error = GB_begin_transaction(GLOBAL_gb_main);
	169	ED4_cursor *cursor = &current_cursor();
	170	int base_pos = (cursor && cursor->owner_of_cursor != 0) ? cursor->get_base_position() : -1;
172	171
173	172	switch (blocktype) {
…	…
176	175	break;
177	176	}
178		case ED4_BT_LINEBLOCK: {
	177	case ED4_BT_LINEBLOCK:
	178	case ED4_BT_MODIFIED_COLUMNBLOCK:
	179	case ED4_BT_COLUMNBLOCK: {
179	180	ED4_list_elem *listElem = ED4_ROOT->selected_objects.first();
180	181	while (listElem && !error) {
…	…
182	183	ED4_sequence_terminal *seqTerm = selectionEntry->object->get_parent(ED4_L_SPECIES)->search_spec_child_rek(ED4_L_SEQUENCE_STRING)->to_sequence_terminal();
183	184
184		error = perform_block_operation_on_whole_sequence(block_operation, seqTerm, repeat);
185		if (error) err_term = seqTerm;
186
187		listElem = listElem->next();
188		}
189		break;
190		}
191		case ED4_BT_MODIFIED_COLUMNBLOCK:
192		case ED4_BT_COLUMNBLOCK: {
193		ED4_list_elem *listElem = ED4_ROOT->selected_objects.first();
194		while (listElem && !error) {
195		ED4_selection_entry selectionEntry = (ED4_selection_entry)listElem->elem();
196		ED4_sequence_terminal *seqTerm = selectionEntry->object->get_parent(ED4_L_SPECIES)->search_spec_child_rek(ED4_L_SEQUENCE_STRING)->to_sequence_terminal();
197
198		error = perform_block_operation_on_part_of_sequence(block_operation, seqTerm, repeat);
199		if (error) err_term = seqTerm;
	185	error = blocktype == ED4_BT_LINEBLOCK
	186	? perform_block_operation_on_whole_sequence(block_operation, seqTerm, repeat)
	187	: perform_block_operation_on_part_of_sequence(block_operation, seqTerm, repeat);
200	188
201	189	listElem = listElem->next();

branches/e4fix/EDIT4/ED4_cursor.cxx

r8201	r8274
1498	1498	species_manager->add_sequence_changed_cb(ed4_bp_sequence_changed_cb, (AW_CL)this);
1499	1499
1500		bool (*is_gap_fun)(char);
	1500	bool (*isGap_fun)(char);
1501	1501	if (species_manager->flag.is_consensus) {
1502	1502	ED4_group_manager *group_manager = base->get_parent(ED4_L_GROUP)->to_group_manager();
1503	1503
1504		seq = group_manager->table().build_consensus_string();
1505		len = strlen(seq);
1506		is_gap_fun = is_consensus_gap;
	1504	seq = group_manager->table().build_consensus_string();
	1505	len = strlen(seq);
	1506	isGap_fun = is_consensus_gap;
1507	1507	}
1508	1508	else {
1509	1509	seq = base->resolve_pointer_to_string_copy(&len);
1510	1510	e4_assert((int)strlen(seq) == len);
1511		is_gap_fun = is_gap;
	1511	isGap_fun = is_gap;
1512	1512	}
1513	1513
…	…
1517	1517	#warning ED4_is_align_character is kinda CharPredicate - refactor
1518	1518	#endif
1519		CharPredicate pred_is_gap(is_gap_fun);
	1519	CharPredicate pred_is_gap(isGap_fun);
1520	1520	initialize(seq, len, pred_is_gap);
1521	1521	calced4base = base;

branches/e4fix/EDIT4/ED4_main.cxx

r8195	r8274
492	492	}
493	493
494		int ~~main(int argc, char **argv~~) {
	494	int ARB_main(int argc, const char *argv[]) {
495	495	const char *data_path = ":";
496	496	const char *err = NULL;
…	…
649	649	AWT_install_cb_guards();
650	650	ED4_ROOT->aw_root->main_loop(); // enter main-loop
651		}
652
	651
	652	return EXIT_SUCCESS;
	653	}
	654

branches/e4fix/EDIT4/ED4_manager.cxx

r8239	r8274
504	504	ED4_list_elem *list_elem;
505	505	bool i_am_consensus = 0;
506		~~ED4_AREA_LEVEL level;~~
507	506	ED4_base *found_member = NULL;
508	507	ED4_extension loc;
509
510		~~#if defined(LIMIT_TOP_AREA_SPACE)~~
511		~~int nr_of_visible_species = 0;~~
512		~~int nr_of_children_in_group = 0;~~
513		~~#endif~~
514	508
515	509	if ((mi == NULL) \|\| (mi->object->spec.level <= spec.level)) {
…	…
548	542
549	543
550		old_parent = object->parent;
551		ED4_multi_species_manager *multi_species_manager = NULL;
552
553		level = get_area_level(&multi_species_manager);
554
555		#if defined(LIMIT_TOP_AREA_SPACE)
556		if (old_parent->get_area_level() != level) { // when moving between two different areas we have to
557		if (level == ED4_A_TOP_AREA \|\| level == ED4_A_BOTTOM_AREA) { // check restrictions
558		nr_of_visible_species = multi_species_manager->count_visible_children();
559
560		if (nr_of_visible_species >= MAX_TOP_AREA_SIZE) {
561		return ED4_R_IMPOSSIBLE;
562		}
563
564		if (object->is_group_manager()) {
565		ED4_group_manager *group_manager = object->to_group_manager();
566
567		if (object->dynamic_prop & ED4_P_IS_FOLDED) {
568		nr_of_children_in_group = 1;
569		}
570		else {
571		nr_of_children_in_group = group_manager->get_defined_level(ED4_L_MULTI_SPECIES)->to_multi_species_manager()->count_visible_children();
572		}
573
574		if (nr_of_children_in_group + nr_of_visible_species > MAX_TOP_AREA_SIZE) {
575		return ED4_R_IMPOSSIBLE;
576		}
577		}
578		}
579		}
580		#endif // LIMIT_TOP_AREA_SPACE
	544	old_parent = object->parent;
581	545
582	546	x_off = 0;
…	…
942	906
943	907	ED4_returncode ED4_main_manager::resize_requested_by_parent() {
944		~~ED4_returncode result = ED4_R_OK;~~
945
946	908	if (update_info.resize) {
947		~~result =~~ ED4_manager::resize_requested_by_parent();
	909	ED4_manager::resize_requested_by_parent();
948	910	current_ed4w()->update_scrolled_rectangle();
949	911	}

branches/e4fix/EDIT4/ED4_no_class.cxx

r8236	r8274
167	167
168	168	if (object->is_terminal()) {
169		~~GB_TYPES gb_type;~~
170
171		~~if (object->get_species_pointer()) {~~
172		~~gb_type = GB_read_type(object->get_species_pointer());~~
173		}
174		~~else {~~
175		~~gb_type = GB_NONE;~~
176		}
177
178	169	ED4_base *species_manager = object->get_parent(ED4_L_SPECIES);
179	170

branches/e4fix/EDIT4/ED4_plugins.cxx

r8156	r8274
113	113	};
114	114
	115	static const PlugIn findPlugin(const char name) {
	116	static PlugIn registered[] = { // register plugins here
	117	PlugIn("SECEDIT", start_SECEDIT_plugin),
	118	#if defined(ARB_OPENGL)
	119	PlugIn("RNA3D", start_RNA3D_plugin),
	120	#endif // ARB_OPENGL
	121	};
115	122
116		~~static PlugIn registered[] = { // register plugins here~~
117		~~PlugIn("SECEDIT", start_SECEDIT_plugin),~~
118		~~#if defined(ARB_OPENGL)~~
119		~~PlugIn("RNA3D", start_RNA3D_plugin),~~
120		~~#endif // ARB_OPENGL~~
121		};
122
123		~~static const PlugIn findPlugin(const char name) {~~
124	123	for (size_t plug = 0; plug<ARRAY_ELEMS(registered); ++plug) {
125	124	if (registered[plug].has_name(name)) {

branches/e4fix/EDIT4/ED4_terminal.cxx

r8239	r8274
380	380	ED4_returncode ED4_terminal::draw_drag_box(AW_pos x, AW_pos y, GB_CSTR text, int cursor_y) // draws drag box of object at location abs_x, abs_y
381	381	{
382		ED4_index i;
383		AW_pos width, height, drag_x, drag_y;
384		AW_pos drag_line_x0[3], drag_line_y0[3];
385		AW_pos drag_line_x1[3], drag_line_y1[3];
386		ED4_base *drag_target = NULL;
387		AW_pos target_x, target_y;
388		ED4_extension location;
389
390		width = extension.size[WIDTH] - 1;
391		height = extension.size[HEIGHT] - 1;
392
393		if (cursor_y!=-1)
394		{
	382	ED4_index i;
	383	AW_pos drag_x, drag_y;
	384	AW_pos drag_line_x0[3], drag_line_y0[3];
	385	AW_pos drag_line_x1[3], drag_line_y1[3];
	386	ED4_base *drag_target = NULL;
	387	AW_pos target_x, target_y;
	388	ED4_extension location;
	389
	390	if (cursor_y!=-1) {
395	391	ED4_device_manager *device_manager = ED4_ROOT->get_device_manager();
396	392	drag_x = 0;

branches/e4fix/EDIT4/ed4_class.hxx

r8239	r8274
74	74
75	75	#endif // IMPLEMENT_DUMP ------------------------------
76
77
78
79		~~// #define LIMIT_TOP_AREA_SPACE // // if defined, top area is size-limited~~
80		~~#ifdef LIMIT_TOP_AREA_SPACE~~
81		~~#define MAX_TOP_AREA_SIZE 10 // size limit for top-area~~
82		~~#endif~~
83	76
84	77	#ifndef ARB_ERROR_H

branches/e4fix/EDIT4/graph_aligner_gui.cxx

r8100	r8274
53	53	#define GA_AWAR_PTLOAD GA_AWAR_ROOT "ptload"
54	54	#define GA_AWAR_COPYMARKREF GA_AWAR_ROOT "copymarkref"
	55	#define GA_AWAR_MATCH_SCORE GA_AWAR_ROOT "match_score"
	56	#define GA_AWAR_MISMATCH_SCORE GA_AWAR_ROOT "mismatch_score"
55	57	#define GA_AWAR_GAP_PEN GA_AWAR_ROOT "gap_pen"
56	58	#define GA_AWAR_GAP_EXT GA_AWAR_ROOT "gap_ext"
…	…
64	66	#define GA_AWAR_THREADS GA_AWAR_ROOT "threads"
65	67	#define GA_AWAR_QSIZE GA_AWAR_ROOT "qsize"
	68	#define GA_AWAR_KMER_LEN GA_AWAR_ROOT "kmer_len"
	69	#define GA_AWAR_KMER_MM GA_AWAR_ROOT "kmer_mm"
	70	#define GA_AWAR_MIN_LEN GA_AWAR_ROOT "min_len"
	71	#define GA_AWAR_WEIGHT GA_AWAR_ROOT "weight"
	72	#define GA_AWAR_INSERT GA_AWAR_ROOT "insert"
	73	#define GA_AWAR_LOWERCASE GA_AWAR_ROOT "lowercase"
	74	#define GA_AWAR_AUTOFILTER GA_AWAR_ROOT "autofilter"
	75	#define GA_AWAR_KMER_NOREL GA_AWAR_ROOT "kmer_norel"
	76	#define GA_AWAR_KMER_NOFAST GA_AWAR_ROOT "kmer_nofast"
	77	#define GA_AWAR_SHOW_DIST GA_AWAR_ROOT "show_dist"
	78	#define GA_AWAR_SHOW_DIFF GA_AWAR_ROOT "show_diff"
	79	#define GA_AWAR_COLOR GA_AWAR_ROOT "color"
	80	#define GA_AWAR_GENE_START GA_AWAR_ROOT "gene_start"
	81	#define GA_AWAR_GENE_END GA_AWAR_ROOT "gene_end"
	82	#define GA_AWAR_FS_COVER_GENE GA_AWAR_ROOT "fs_cover_gene"
66	83
67	84	void create_sina_variables(AW_root *root, AW_default db1) {
…	…
78	95	root->awar_float(GA_AWAR_GAP_PEN, 5.0, db1);
79	96	root->awar_float(GA_AWAR_GAP_EXT, 2.0, db1);
	97	root->awar_float(GA_AWAR_MATCH_SCORE, 2.0, db1);
	98	root->awar_float(GA_AWAR_MISMATCH_SCORE, -1.0, db1);
80	99	root->awar_int(GA_AWAR_ADVANCED, 0, db1);
81		root->awar_int(GA_AWAR_FS_MIN, 15, db1);
	100	root->awar_int(GA_AWAR_FS_MIN, 40, db1);
82	101	root->awar_int(GA_AWAR_FS_MAX, 40, db1);
83	102	root->awar_float(GA_AWAR_FS_MSC, .7, db1);
…	…
87	106	root->awar_int(GA_AWAR_THREADS, 1, db1);
88	107	root->awar_int(GA_AWAR_QSIZE, 1, db1);
	108	root->awar_int(GA_AWAR_KMER_LEN, 10, db1);
	109	root->awar_int(GA_AWAR_KMER_MM, 0, db1);
	110	root->awar_int(GA_AWAR_MIN_LEN, 150, db1);
	111	root->awar_float(GA_AWAR_WEIGHT, 1, db1);
	112	root->awar_string(GA_AWAR_INSERT, "shift", db1);
	113	root->awar_string(GA_AWAR_LOWERCASE, "none", db1);
	114	root->awar_string(GA_AWAR_AUTOFILTER, "none", db1);
	115	root->awar_int(GA_AWAR_KMER_NOREL, 0, db1);
	116	root->awar_int(GA_AWAR_KMER_NOFAST, 0, db1);
	117	root->awar_int(GA_AWAR_SHOW_DIST, 0, db1);
	118	root->awar_int(GA_AWAR_SHOW_DIFF, 0, db1);
	119	root->awar_int(GA_AWAR_COLOR, 1, db1);
	120	root->awar_int(GA_AWAR_GENE_START, 0, db1);
	121	root->awar_int(GA_AWAR_GENE_END, 0, db1);
	122	root->awar_int(GA_AWAR_FS_COVER_GENE, 1, db1);
89	123	}
90	124
…	…
95	129
96	130	if (sina) {
97		int exitstatus = system(GBS_global_string("%s --has-cli-vers 1", sina));
	131	int exitstatus = system(GBS_global_string("%s --has-cli-vers ARB5.99", sina));
98	132	exitstatus = WEXITSTATUS(exitstatus);
99	133
…	…
234	268	GBS_strcat(cl, root->awar(GA_AWAR_CMD)->read_char_pntr());
235	269	GBS_strcat(cl, " -i :");
236		~~GBS_strcat(cl, " --queue-size "); GBS_intcat(cl, root->awar(GA_AWAR_QSIZE)->read_int());~~
237		~~GBS_strcat(cl, " --ncpu "); GBS_intcat(cl, root->awar(GA_AWAR_THREADS)->read_int());~~
238		~~GBS_strcat(cl, " --verbosity "); GBS_strcat(cl, root->awar(GA_AWAR_LOGLEVEL)->read_char_pntr());~~
239	270	GBS_strcat(cl, " --ptdb "); GBS_strcat(cl, root->awar(GA_AWAR_PTLOAD)->read_int() ? pt_db : ":");
240	271	GBS_strcat(cl, " --ptport "); GBS_strcat(cl, pt_server);
…	…
248	279	GBS_strcat(cl, " --fs-req-full "); GBS_intcat(cl, root->awar(GA_AWAR_MIN_FULL)->read_int());
249	280	GBS_strcat(cl, " --fs-full-len "); GBS_intcat(cl, root->awar(GA_AWAR_FULL_MINLEN)->read_int());
	281	GBS_strcat(cl, " --fs-kmer-len "); GBS_intcat(cl, root->awar(GA_AWAR_KMER_LEN)->read_int());
	282	GBS_strcat(cl, " --fs-kmer-mm "); GBS_intcat(cl, root->awar(GA_AWAR_KMER_MM)->read_int());
	283	GBS_strcat(cl, " --fs-min-len "); GBS_intcat(cl, root->awar(GA_AWAR_MIN_LEN)->read_int());
	284	GBS_strcat(cl, " --fs-weight "); GBS_intcat(cl, root->awar(GA_AWAR_WEIGHT)->read_float());
250	285	GBS_strcat(cl, " --pen-gap "); GBS_floatcat(cl, root->awar(GA_AWAR_GAP_PEN)->read_float());
251	286	GBS_strcat(cl, " --pen-gapext "); GBS_floatcat(cl, root->awar(GA_AWAR_GAP_EXT)->read_float());
	287	GBS_strcat(cl, " --match-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MATCH_SCORE)->read_float());
	288	GBS_strcat(cl, " --mismatch-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MISMATCH_SCORE)->read_float());
252	289	GBS_strcat(cl, " --prot-level "); GBS_intcat(cl, root->awar(GA_AWAR_PROTECTION)->read_int());
253	290	GBS_strcat(cl, " --select-file "); GBS_strcat(cl, tmpfile);
254
	291	GBS_strcat(cl, " --insertion "); GBS_strcat(cl, root->awar(GA_AWAR_INSERT)->read_char_pntr());
	292	GBS_strcat(cl, " --lowercase "); GBS_strcat(cl, root->awar(GA_AWAR_LOWERCASE)->read_char_pntr());
	293	GBS_strcat(cl, " --auto-filter-field "); GBS_strcat(cl, root->awar(GA_AWAR_AUTOFILTER)->read_char_pntr());
	294	GBS_strcat(cl, " --gene-start "); GBS_intcat(cl, root->awar(GA_AWAR_GENE_START)->read_int());
	295	GBS_strcat(cl, " --gene-end "); GBS_intcat(cl, root->awar(GA_AWAR_GENE_END)->read_int());
	296	GBS_strcat(cl, " --fs-cover-gene ");GBS_intcat(cl, root->awar(GA_AWAR_FS_COVER_GENE)->read_int());
	297
	298
	299	if (root->awar(GA_AWAR_KMER_NOREL)->read_int()) GBS_strcat(cl, " --fs-kmer-norel ");
	300	if (root->awar(GA_AWAR_KMER_NOFAST)->read_int()) GBS_strcat(cl, " --fs-kmer-no-fast ");
	301	if (root->awar(GA_AWAR_SHOW_DIST)->read_int()) GBS_strcat(cl, " --show-dist ");
	302	if (root->awar(GA_AWAR_SHOW_DIFF)->read_int()) GBS_strcat(cl, " --show-diff ");
	303	if (root->awar(GA_AWAR_COLOR)->read_int()) GBS_strcat(cl, " --color");
255	304	if (root->awar(GA_AWAR_REALIGN)->read_int()) GBS_strcat(cl, " --realign");
256		~~if (root->awar(GA_AWAR_COPYMARKREF)->read_int()) GBS_strcat(cl, " --markcopy");~~
257	305
258	306	gb_error = GB_xcmd(GBS_mempntr(cl), true, false);
…	…
347	395
348	396	aws->at_newline();
349		~~aws->callback(AW_POPUP, (AW_CL)create_select_sai_window, (AW_CL)0);~~
350		~~aws->label("Pos. Var.:");~~
351		~~aws->create_button("SELECT_SAI", GA_AWAR_SAI);~~
352		~~aws->button_length(12);~~
353
354
355		~~aws->at_newline();~~
356	397	aws->label_length(0);
357	398	aws->create_option_menu(GA_AWAR_OVERHANG, "Overhang placement");
…	…
361	402	aws->update_option_menu();
362	403
	404	aws->at_newline();
	405	aws->create_option_menu(GA_AWAR_INSERT, "Handling of unmappable insertions", "I");
	406	aws->insert_option("Shift surrounding bases", 0, "shift");
	407	aws->insert_option("Forbid during DP alignment", 0, "forbid");
	408	aws->insert_option("Delete bases", 0, "remove");
	409	aws->update_option_menu();
	410
	411	aws->at_newline();
	412	aws->create_option_menu(GA_AWAR_LOWERCASE, "Character Case","C");
	413	aws->insert_option("Do not modify", 0, "original");
	414	aws->insert_option("Show unaligned bases as lower case", 0, "unaligned");
	415	aws->insert_option("Uppercase all", 0, "none");
	416	aws->update_option_menu();
	417
	418	aws->at_newline();
	419	aws->label("Family conservation weight (0-1)");
	420	aws->create_input_field(GA_AWAR_WEIGHT, 3);
	421
	422	aws->at_newline();
	423	aws->label("Size of full-length sequences");
	424	aws->create_input_field(GA_AWAR_FULL_MINLEN, 5);
	425
363	426	if (adv) {
364	427	aws->at_newline();
365	428	aws->at_shift(0, hgap);
	429
	430	aws->at_newline();
	431	aws->callback(AW_POPUP, (AW_CL)create_select_sai_window, (AW_CL)0);
	432	aws->label("Pos. Var.:");
	433	aws->create_button("SELECT_SAI", GA_AWAR_SAI);
	434	aws->button_length(12);
	435
	436	aws->at_newline();
	437	aws->label("Field used for automatic filter selection");
	438	aws->create_input_field(GA_AWAR_AUTOFILTER, 20);
366	439
367	440	aws->label("Turn check");
…	…
376	449	aws->create_toggle(GA_AWAR_PTLOAD);
377	450
	451	/*
378	452	aws->at_newline();
379	453	aws->label("(Copy and) mark sequences used as reference");
380	454	aws->create_toggle(GA_AWAR_COPYMARKREF);
	455	*/
381	456
382	457	aws->at_newline();
…	…
387	462	aws->create_input_field(GA_AWAR_GAP_PEN, 5);
388	463	aws->create_input_field(GA_AWAR_GAP_EXT, 5);
	464
	465	aws->at_newline();
	466	aws->label("Match score");
	467	aws->create_input_field(GA_AWAR_MATCH_SCORE, 3);
	468	aws->label("Mismatch score");
	469	aws->create_input_field(GA_AWAR_MISMATCH_SCORE, 3);
389	470
390	471	aws->at_newline();
…	…
395	476
396	477	aws->at_newline();
397		aws->label("~~Use at least~~");
	478	aws->label("Minimal number of full length sequences");
398	479	aws->create_input_field(GA_AWAR_MIN_FULL, 3);
399		aws->label("sequences with at least");
400		aws->create_input_field(GA_AWAR_FULL_MINLEN, 5);
401		aws->label("bases as reference");
402
403		aws->at_newline();
404		aws->label("Max threads");
405		aws->create_input_field(GA_AWAR_THREADS, 3);
406		aws->label("Queue size");
407		aws->create_input_field(GA_AWAR_QSIZE, 3);
	480
	481	aws->at_newline();
	482	aws->label("Family search oligo length / mismatches");
	483	aws->create_input_field(GA_AWAR_KMER_LEN, 3);
	484	aws->create_input_field(GA_AWAR_KMER_MM, 3);
	485
	486	aws->at_newline();
	487	aws->label("Minimal reference sequence length");
	488	aws->create_input_field(GA_AWAR_MIN_LEN, 5);
	489
	490	aws->at_newline();
	491	aws->label("Alignment bounds: start");
	492	aws->create_input_field(GA_AWAR_GENE_START, 6);
	493	aws->label("end");
	494	aws->create_input_field(GA_AWAR_GENE_END, 6);
	495
	496	aws->at_newline();
	497	aws->label("Number of references required to touch bounds");
	498	aws->create_input_field(GA_AWAR_FS_COVER_GENE, 3);
	499
	500	aws->at_newline();
	501	aws->label("Disable fast search");
	502	aws->create_toggle(GA_AWAR_KMER_NOFAST);
	503
	504	aws->at_newline();
	505	aws->label("Score search results by absolute oligo match count");
	506	aws->create_toggle(GA_AWAR_KMER_NOREL);
408	507
409	508	aws->at_newline();
…	…
428	527	aws->update_option_menu();
429	528
	529	/*
430	530	aws->at_newline();
431	531	aws->create_option_menu(GA_AWAR_LOGLEVEL, "Logging level", "L");
…	…
437	537	aws->insert_option("debug more", 0, "6");
438	538	aws->update_option_menu();
	539	*/
	540
	541	aws->at_newline();
	542	aws->label("Show changed sections of alignment");
	543	aws->create_toggle(GA_AWAR_SHOW_DIFF);
	544	aws->label("color bases");
	545	aws->create_toggle(GA_AWAR_COLOR);
	546
	547	aws->at_newline();
	548	aws->label("Show statistics");
	549	aws->create_toggle(GA_AWAR_SHOW_DIST);
439	550
440	551	aws->get_window_size(winx, winy);

branches/e4fix/EDIT4/needs_libs

r7801	r8274
1	1	# libraries needed to link against EDIT4/EDIT4.a
2	2
3		ARB_GDE/ARB_GDE.a # needed for ~~what?~~
	3	ARB_GDE/ARB_GDE.a # needed for pretty print seq
4	4	$(RNA3D_LIB)
5	5	SECEDIT/SECEDIT.a
…	…
7	7	SL/FAST_ALIGNER/FAST_ALIGNER.a
8	8	SL/TRANSLATE/TRANSLATE.a
9		~~SL/ITEMS/ITEMS.a~~
10	9	STAT/STAT.a
11	10

branches/e4fix/GDE/Makefile

r7428	r8274
3	3	CLUSTAL/CLUSTAL.dummy \
4	4	SUPPORT/SUPPORT.dummy \
5		~~MOLPHY/MOLPHY.dummy \~~
6	5	AxML/AxML.dummy \
7	6	RAxML/RAxML.dummy \
…	…
54	53	endif
55	54
56		~~proto: MOLPHY/MOLPHY.proto~~
57
58	55	depends: $(ARCHS:.dummy=.depend)
59	56

branches/e4fix/GDE/PHYML/Makefile

r5829	r8274
31	31	ifdef DARWIN
32	32	CFLAGS += -fPIC
33		~~else~~
34		~~CFLAGS += -static~~
35	33	endif
36	34

branches/e4fix/GDEHELP/ARB_GDEmenus.source

r7492	r8274
51	51	menumeta:X
52	52	#include <fastdnaml.genmenu>
53		~~#include <molphy.genmenu>~~
54	53
55	54	menu:Phylogeny max. Likelyhood

branches/e4fix/GDEHELP/Makefile.helpfiles

r7409	r8274
36	36
37	37	$(GENHELPDEST)/dnaml.help: $(AXML_HELP) $(FASTDNAML_DOC)
38		~~./genhelptree.sh $@ "$(subst .help,,$(notdir $@))" $(HEADER) $^~~
39
40		~~PROTML=$(GDE)/MOLPHY/doc~~
41		~~PROTML_DOC_NAMES=protml protml_cli~~
42		~~PROTML_DOCS=$(addsuffix .doc,$(addprefix $(PROTML)/,$(PROTML_DOC_NAMES)))~~
43
44		~~$(GENHELPDEST)/protml.help: $(PROTML_DOCS)~~
45	38	./genhelptree.sh $@ "$(subst .help,,$(notdir $@))" $(HEADER) $^
46	39

branches/e4fix/GENOM/GEN_interface.cxx

r7916	r8274
22	22	#include <arbdbt.h>
23	23	#include <adGene.h>
24		#include <~~../GENOM_IMPORT/~~Location.h>
	24	#include <Location.h>
25	25	#include <arb_strarray.h>
26	26	#include <arb_strbuf.h>

branches/e4fix/GENOM/Makefile

r7916	r8274
173	173	GEN_graphic.o: $(ARBHOME)/INCLUDE/test_global.h
174	174
175		~~GEN_interface.o: ../GENOM_IMPORT/defs.h~~
176		~~GEN_interface.o: ../GENOM_IMPORT/Location.h~~
177		~~GEN_interface.o: ../GENOM_IMPORT/types.h~~
178	175	GEN_interface.o: GEN.hxx
179	176	GEN_interface.o: GEN_local.hxx
…	…
210	207	GEN_interface.o: $(ARBHOME)/INCLUDE/item_sel_list.h
211	208	GEN_interface.o: $(ARBHOME)/INCLUDE/items.h
	209	GEN_interface.o: $(ARBHOME)/INCLUDE/Location.h
212	210	GEN_interface.o: $(ARBHOME)/INCLUDE/smartptr.h
213	211	GEN_interface.o: $(ARBHOME)/INCLUDE/test_global.h

branches/e4fix/GENOM/needs_libs

r7801	r8274
1	1	# libraries needed to link against GENOM/GENOM.a
2	2
3		~~# depends on NTREE/NTREE.a # fix this~~
4
5	3	SL/DB_UI/DB_UI.a
6		#SL/DB_SCANNER/DB_SCANNER.a
7		#SL/DB_QUERY/DB_QUERY.a
	4	SL/LOCATION/LOCATION.a
8	5	SL/NDS/NDS.a
9	6	SL/TRANSLATE/TRANSLATE.a

branches/e4fix/GENOM_IMPORT/DBwriter.h

r7623	r8274
48	48	};
49	49
50		typedef ~~map<~~string, int> NameCounter;
	50	typedef std::map<std::string, int> NameCounter;
51	51	class Translator;
52	52

branches/e4fix/GENOM_IMPORT/Feature.cxx

r6385	r8274
9	9	// //
10	10	// ================================================================ //
	11
11	12	#include "Feature.h"
	13	#include "types.h"
12	14	#include <cctype>
13	15

branches/e4fix/GENOM_IMPORT/Feature.h

r6381	r8274
17	17
18	18	class Feature {
19		st~~ring~~ type;
	19	std::string type;
20	20	LocationPtr location;
21	21	stringMap qualifiers; // qualifiers with content (content of multiple identical qualifiers gets merged)
22	22
23	23	public:
24		Feature(const st~~ring& Type, const~~ string& locationString);
	24	Feature(const std::string& Type, const std::string& locationString);
25	25
26		void addQualifiedEntry(const st~~ring& qualifier, const~~ string& value);
	26	void addQualifiedEntry(const std::string& qualifier, const std::string& value);
27	27
28		string createGeneName() const; // creates a (non-unique) default name for gene
	28	std::string createGeneName() const; // creates a (non-unique) default name for gene
29	29
30		const string& getType() const { return type; }
	30	const std::string& getType() const { return type; }
31	31	const Location& getLocation() const { return *location; }
32	32	const stringMap& getQualifiers() const { return qualifiers; }

branches/e4fix/GENOM_IMPORT/GenomeImport.cxx

r6381	r8274
17	17	#include <AW_rename.hxx>
18	18	#include <aw_question.hxx>
	19	#include <arb_str.h>
19	20
20	21	using namespace std;

branches/e4fix/GENOM_IMPORT/Importer.cxx

r6490	r8274
13	13	#include "DBwriter.h"
14	14	#include <arbdb.h>
	15	#include <arb_str.h>
15	16
16	17	using namespace std;

branches/e4fix/GENOM_IMPORT/Importer.h

r7623	r8274
52	52	};
53	53
54		typedef SmartPtr<Feature> FeaturePtr;
55		typedef SmartPtr<FeatureLine> FeatureLinePtr;
56		typedef vector<FeatureLinePtr> FeatureLines;
	54	typedef SmartPtr<Feature> FeaturePtr;
	55	typedef SmartPtr<FeatureLine> FeatureLinePtr;
	56	typedef std::vector<FeatureLinePtr> FeatureLines;
57	57
58	58	class Importer : virtual Noncopyable {

branches/e4fix/GENOM_IMPORT/Makefile

r7806	r8274
6	6
7	7	# objects for library
8		CPP_OBJECTS = \
9		GenomeImport.o \
10		Importer.o \
11		DBwriter.o \
12		SequenceBuffer.o \
13		MetaInfo.o \
14		Feature.o \
15		Location.o \
16		tools.o \
	8	CPP_OBJECTS=$(subst .cxx,.o,$(wildcard *.cxx))
17	9
18	10	# --------------------------------------------------------------------------------
…	…
56	48	DBwriter.o: GenomeImport.h
57	49	DBwriter.o: Importer.h
58		~~DBwriter.o: Location.h~~
59	50	DBwriter.o: MetaInfo.h
60	51	DBwriter.o: MetaTag.h
…	…
81	72	DBwriter.o: $(ARBHOME)/INCLUDE/GEN.hxx
82	73	DBwriter.o: $(ARBHOME)/INCLUDE/items.h
	74	DBwriter.o: $(ARBHOME)/INCLUDE/Location.h
83	75	DBwriter.o: $(ARBHOME)/INCLUDE/smartptr.h
84	76	DBwriter.o: $(ARBHOME)/INCLUDE/test_global.h
…	…
87	79	Feature.o: defs.h
88	80	Feature.o: Feature.h
89		~~Feature.o: Location.h~~
90	81	Feature.o: types.h
91	82	Feature.o: $(ARBHOME)/INCLUDE/arb_assert.h
…	…
93	84	Feature.o: $(ARBHOME)/INCLUDE/arbtools.h
94	85	Feature.o: $(ARBHOME)/INCLUDE/dupstr.h
	86	Feature.o: $(ARBHOME)/INCLUDE/Location.h
95	87	Feature.o: $(ARBHOME)/INCLUDE/smartptr.h
96	88	Feature.o: $(ARBHOME)/INCLUDE/test_global.h
…	…
101	93	GenomeImport.o: GenomeImport.h
102	94	GenomeImport.o: Importer.h
103		~~GenomeImport.o: Location.h~~
104	95	GenomeImport.o: MetaInfo.h
105	96	GenomeImport.o: MetaTag.h
…	…
113	104	GenomeImport.o: $(ARBHOME)/INCLUDE/arb_error.h
114	105	GenomeImport.o: $(ARBHOME)/INCLUDE/arb_msg.h
	106	GenomeImport.o: $(ARBHOME)/INCLUDE/arb_str.h
115	107	GenomeImport.o: $(ARBHOME)/INCLUDE/arb_string.h
116	108	GenomeImport.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
124	116	GenomeImport.o: $(ARBHOME)/INCLUDE/dupstr.h
125	117	GenomeImport.o: $(ARBHOME)/INCLUDE/FileBuffer.h
	118	GenomeImport.o: $(ARBHOME)/INCLUDE/Location.h
126	119	GenomeImport.o: $(ARBHOME)/INCLUDE/smartptr.h
127	120	GenomeImport.o: $(ARBHOME)/INCLUDE/test_global.h
…	…
132	125	Importer.o: GenomeImport.h
133	126	Importer.o: Importer.h
134		~~Importer.o: Location.h~~
135	127	Importer.o: MetaInfo.h
136	128	Importer.o: MetaTag.h
…	…
143	135	Importer.o: $(ARBHOME)/INCLUDE/arb_error.h
144	136	Importer.o: $(ARBHOME)/INCLUDE/arb_msg.h
	137	Importer.o: $(ARBHOME)/INCLUDE/arb_str.h
145	138	Importer.o: $(ARBHOME)/INCLUDE/arb_string.h
146	139	Importer.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
150	143	Importer.o: $(ARBHOME)/INCLUDE/dupstr.h
151	144	Importer.o: $(ARBHOME)/INCLUDE/FileBuffer.h
	145	Importer.o: $(ARBHOME)/INCLUDE/Location.h
152	146	Importer.o: $(ARBHOME)/INCLUDE/smartptr.h
153	147	Importer.o: $(ARBHOME)/INCLUDE/test_global.h
154
155		~~Location.o: defs.h~~
156		~~Location.o: Location.h~~
157		~~Location.o: tools.h~~
158		~~Location.o: types.h~~
159		~~Location.o: $(ARBHOME)/INCLUDE/ad_prot.h~~
160		~~Location.o: $(ARBHOME)/INCLUDE/adGene.h~~
161		~~Location.o: $(ARBHOME)/INCLUDE/arb_assert.h~~
162		~~Location.o: $(ARBHOME)/INCLUDE/arb_core.h~~
163		~~Location.o: $(ARBHOME)/INCLUDE/arb_error.h~~
164		~~Location.o: $(ARBHOME)/INCLUDE/arb_msg.h~~
165		~~Location.o: $(ARBHOME)/INCLUDE/arb_string.h~~
166		~~Location.o: $(ARBHOME)/INCLUDE/arbdb.h~~
167		~~Location.o: $(ARBHOME)/INCLUDE/arbdb_base.h~~
168		~~Location.o: $(ARBHOME)/INCLUDE/arbtools.h~~
169		~~Location.o: $(ARBHOME)/INCLUDE/attributes.h~~
170		~~Location.o: $(ARBHOME)/INCLUDE/dupstr.h~~
171		~~Location.o: $(ARBHOME)/INCLUDE/smartptr.h~~
172		~~Location.o: $(ARBHOME)/INCLUDE/test_global.h~~
173		~~Location.o: $(ARBHOME)/INCLUDE/test_unit.h~~
174	148
175	149	MetaInfo.o: defs.h
…	…
193	167	SequenceBuffer.o: $(ARBHOME)/INCLUDE/smartptr.h
194	168	SequenceBuffer.o: $(ARBHOME)/INCLUDE/test_global.h
195
196		~~tools.o: defs.h~~
197		~~tools.o: tools.h~~
198		~~tools.o: types.h~~
199		~~tools.o: $(ARBHOME)/INCLUDE/arb_assert.h~~
200		~~tools.o: $(ARBHOME)/INCLUDE/arb_core.h~~
201		~~tools.o: $(ARBHOME)/INCLUDE/arbtools.h~~
202		~~tools.o: $(ARBHOME)/INCLUDE/dupstr.h~~
203		~~tools.o: $(ARBHOME)/INCLUDE/test_global.h~~

branches/e4fix/GENOM_IMPORT/MetaInfo.h

r7623	r8274
22	22	Reference() {}
23	23
24		void ~~add(const string& field, const~~ string& content);
25		const st~~ring *get(const~~ string& field) const;
	24	void add(const std::string& field, const std::string& content);
	25	const std::string *get(const std::string& field) const;
26	26
27	27	void getKeys(stringSet& keys) const; // get reference keys
…	…
30	30
31	31	class References : virtual Noncopyable { // holds information of all reference sections
32		vector<Reference> refs;
33		Reference *latest;
34		int ref_count;
	32	std::vector<Reference> refs;
	33	Reference *latest;
	34	int ref_count;
35	35
36	36	public:
…	…
38	38
39	39	void start(); // start a new reference
40		void add(const st~~ring& field, const~~ string& content) {
	40	void add(const std::string& field, const std::string& content) {
41	41	gi_assert(latest);
42	42	latest->add(field, content);
43	43	}
44	44
45		void add_dbid(const string& content); // special handling for 'RX' field
	45	void add_dbid(const std::string& content); // special handling for 'RX' field
46	46
47	47	void getKeys(stringSet& keys) const; // get reference keys
48		st~~ring tagged_content(const~~ string& refkey) const;
	48	std::string tagged_content(const std::string& refkey) const;
49	49
50	50	#if defined(DEBUG)
…	…
59	59	MetaInfo() {}
60	60
61		void add(const MetaTag *meta, const string& content, bool allow_multiple_entries);
	61	void add(const MetaTag *meta, const std::string& content, bool allow_multiple_entries);
62	62
63	63	#if defined(DEBUG)
…	…
67	67	const stringMap& getEntries() const { return entries; }
68	68
69		const string& getAccessionNumber() const;
	69	const std::string& getAccessionNumber() const;
70	70	};
71	71

branches/e4fix/GENOM_IMPORT/MetaTag.h

r7623	r8274
31	31
32	32	struct MetaTag {
33		st~~ring tag;~~ // tag name (in flatfile)
34		st~~ring field;~~ // field name
	33	std::string tag; // tag name (in flatfile)
	34	std::string field; // field name
35	35	MetaTagType type;
36	36	};
37	37
38		typedef ~~map<~~string, const MetaTag *> MetaTagMap;
	38	typedef std::map<std::string, const MetaTag *> MetaTagMap;
39	39
40	40	class MetaTagTranslator : virtual Noncopyable {
…	…
49	49	}
50	50
51		const MetaTag *get(const string& tag) const {
	51	const MetaTag *get(const std::string& tag) const {
52	52	MetaTagMap::const_iterator found = translate.find(tag);
53	53	if (found != translate.end()) return found->second;

branches/e4fix/GENOM_IMPORT/SequenceBuffer.h

r7623	r8274
28	28	size_t getCount(unsigned char idx) const { return count[idx]; }
29	29	size_t getCount() const { return all; }
30		void countChars(const string& line);
	30	void countChars(const std::string& line);
31	31
32	32	void clear();
…	…
37	37
38	38	class BaseCounter {
39		st~~ring source;~~ // where does information originate from
40		size_t ~~count[BC_COUNTERS];~~ // number of occurrences of single bases
	39	std::string source; // where does information originate from
	40	size_t count[BC_COUNTERS]; // number of occurrences of single bases
41	41
42	42	SmartPtr<CharCounter> char_count; // character counter (used by addLine)
…	…
45	45
46	46	public:
47		BaseCounter(const string& Source)
	47	BaseCounter(const std::string& Source)
48	48	: source(Source)
49	49	{
…	…
56	56
57	57	void startLineCounter();
58		void addLine(const string& line) {
	58	void addLine(const std::string& line) {
59	59	gi_assert(!char_count.isNull()); // call startLineCounter before!
60	60	char_count->countChars(line);
…	…
82	82	~SequenceBuffer();
83	83
84		void addLine(const string& line) {
	84	void addLine(const std::string& line) {
85	85	lines.push_back(line);
86	86	baseCounter.addLine(line);

branches/e4fix/GENOM_IMPORT/defs.h

r7044	r8274
15	15	#include <string>
16	16	#endif
17
18		~~using std::string;~~
19	17
20	18	#ifndef ARB_ASSERT_H

branches/e4fix/GENOM_IMPORT/tools.h

r7044	r8274
22	22	#endif
23	23
24
25		inline bool beginsWith(const string& str, const string& start) {
26		return str.find(start) == 0;
27		}
28
29		inline bool endsWith(const string& str, const string& postfix) {
30		size_t slen = str.length();
31		size_t plen = postfix.length();
32
33		if (plen>slen) { return false; }
34		return str.substr(slen-plen) == postfix;
35		}
36
37		inline void appendSpaced(string& str, const string& toAppend) {
	24	inline void appendSpaced(std::string& str, const std::string& toAppend) {
38	25	if (!toAppend.empty()) {
39	26	if (!str.empty()) str.append(1, ' ');
…	…
42	29	}
43	30
44		~~bool parseInfix(const string &str, const string& prefix, const string& postfix, string& foundInfix);~~
45
46	31	// --------------------------------------------------------------------------------
47	32
48		#define CURRENT_REST string(pos, end).c_str()
	33	#define CURRENT_REST std::string(pos, end).c_str()
49	34
50	35	struct StringParser {
51	36	stringCIter pos, end;
52	37
53		StringParser(const string& str) : pos(str.begin()), end(str.end()) {}
	38	StringParser(const std::string& str) : pos(str.begin()), end(str.end()) {}
54	39
55	40	bool atEnd() const { return pos == end; }
…	…
61	46	void advance(size_t offset) { std::advance(pos, offset); }
62	47
63		st~~ring rest() const { return~~ string(pos, end); }
	48	std::string rest() const { return std::string(pos, end); }
64	49
65	50	stringCIter find(char c) {
…	…
112	97	}
113	98
114		string extractWord(const char *delimiter = " ") {
	99	std::string extractWord(const char *delimiter = " ") {
115	100	if (atEnd() \|\| strchr(delimiter, *pos) != 0) {
116	101	throw GBS_global_string("Expected non-delimiter at '%s'", CURRENT_REST);
…	…
120	105
121	106	while (!atEnd() && strchr(delimiter, *pos) == 0) ++pos;
122		return string(start, pos);
	107	return std::string(start, pos);
123	108	}
124	109

branches/e4fix/GENOM_IMPORT/types.h

r7044	r8274
26	26	#endif
27	27
28		~~using std::vector~~;
29		~~using std::m~~ap;
30		~~using std::set~~;
	28	typedef std::set<std::string> stringSet;
	29	typedef std::map<std::string, std::string> stringMap;
	30	typedef std::vector<std::string> stringVector;
31	31
32		typedef set<string> stringSet;
33		typedef map<string, string> stringMap;
34		typedef vector<string> stringVector;
35
36		#define DEFINE_ITERATORS(type) \
37		typedef type::iterator type##Iter; \
38		typedef type::const_iterator type##CIter; \
39		typedef type::reverse_iterator type##RIter; \
40		typedef type::const_reverse_iterator type##CRIter
41
42		DEFINE_ITERATORS(string);
	32	DEFINE_NAMED_ITERATORS(std::string, string);
43	33	DEFINE_ITERATORS(stringSet);
44	34	DEFINE_ITERATORS(stringMap);

branches/e4fix/GL/glpng/glpng.c

r7811	r8274
49	49
50	50	static unsigned char DefaultAlphaCallback(unsigned char red, unsigned char green, unsigned char blue) {
51		red = green = blue; // unused
	51	red = red; // unused
	52	green = green; // unused
	53	blue = blue; // unused
52	54	return 255;
53	55	}

branches/e4fix/HELP_SOURCE/Makefile

r7819	r8274
228	228	$(HELP2XML): arb_help2xml.o $(LIBS)
229	229	# @@@ when backtracing code is in libCORE, link vs ARBDB is no longer needed!
230		$(LINK_EXECUTABLE) $@ $< $(LIBS) $(LIBPATH) $(ARBDB_LIB) $(EXECLIBS)
	230	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $< $(LIBS) $(LIBPATH) $(ARBDB_LIB) $(EXECLIBS)
231	231
232	232

branches/e4fix/HELP_SOURCE/arb_help2xml.cxx

r7815	r8274
1319	1319	}
1320	1320
1321		int ~~main(int argc,~~ char *argv[]) {
	1321	int ARB_main(int argc, const char *argv[]) {
1322	1322	Helpfile help;
1323	1323	string arb_help;

branches/e4fix/HELP_SOURCE/oldhelp/nt_tree_settings.hlp

r3190	r8274
37	37	- 'Grey Level of Groups%' (for printing/Xfig only)
38	38
	39	- Text zoom/pad
	40	Select toggle to consider text for default zoom (otherwise only tree-structure is considered).
	41	Add extra padding in pixel (= amount of extra space for text; may be negative)
	42
39	43	The changes can be saved to files 'arb_prop*' located in the
40	44	users home directory by choosing the "Save Defaults'.

branches/e4fix/MULTI_PROBE/MP_mo_liste.cxx

r7415	r8274
189	189	}
190	190
191		long MO_Liste::put_entry(const char* name)
192		{
193		long hashreturnval;
194
	191	long MO_Liste::put_entry(const char* name) {
195	192	// Pruefe: Gibts den Bakter schon in dieser Liste??
196	193	if (get_index_by_entry(name)) // wanns den Bakter scho gibt
…	…
201	198	{
202	199	mo_liste[current] = new Bakt_Info(name); // MEL koennte mit match_name zusammenhaengen
203		~~hashreturnval =~~ GBS_write_hash(hashptr, name, current);
	200	GBS_write_hash(hashptr, name, current);
204	201	current++;
205	202	}

branches/e4fix/MULTI_PROBE/MP_probe.cxx

r7812	r8274
182	182	int i, j, k, counter=0;
183	183	probe *temp_probe;
184		~~ST_Container *stc;~~
185	184	AW_window *aww;
186	185	char ptr, ptr2;
…	…
203	202	}
204	203
205		~~stc = mp_main->get_stc();~~
206	204	aww = mp_main->get_mp_window()->get_window();
207	205	aww->init_list_entry_iterator(selected_list); // initialisieren

branches/e4fix/MULTI_PROBE/MP_sondentopf.cxx

r6867	r8274
70	70	Sonde* ST_Container::cache_Sonde(char *name, int allowed_mis, double outside_mis)
71	71	{
72		~~long hashreturnval;~~
73	72	char* name_for_plist = strdup(name);
74	73	Sonde* s = new Sonde(name, allowed_mis, outside_mis);
…	…
77	76	s->gen_Hitliste(Bakterienliste);
78	77
79		~~hashreturnval =~~ GBS_write_hash(cachehash, name, (long) s);
	78	GBS_write_hash(cachehash, name, (long) s);
80	79	// Reine Sonde plus Hitliste geschrieben, der Zeiger auf die Sonde liegt als long gecastet im Hash
81	80	return s;

branches/e4fix/Makefile

r8221	r8274
58	58	4.3 4.3.1 4.3.2 4.3.3 4.3.4 \
59	59	4.4 4.4.1 4.4.3 4.4.5 \
60		4.5.2
	60	4.5.2 \
	61	4.6.1
61	62
62	63	ALLOWED_GCC_VERSIONS=$(ALLOWED_GCC_4xx_VERSIONS)
…	…
115	116	cflags := -O4# compiler flags (C and C++)
116	117	ifndef DARWIN
117		lflags += -O99 ~~--strip-all~~# linker flags
	118	lflags += -O99# linker flags
118	119	endif
119	120	endif
…	…
373	374	ldynamic =
374	375	else
375		cdynamic = -rdynamic
376		ldynamic = --export-dynamic
	376	cdynamic = -rdynamic -Wl,--export-dynamic
	377	ldynamic = --export-dynamic
377	378	endif
378	379	endif
…	…
404	405	PP := $(CPPreal)# preprocessor
405	406
406		lflags += $(ldynamic)
407
408		LINK_STATIC_LIB := ld $(lflags) -r -o# link static lib
	407	LINK_STATIC_LIB := ld $(lflags) $(ldynamic) -r -o# link static lib
409	408	LINK_EXECUTABLE := $(GPP) $(lflags) $(cdynamic) -o# link executable (c++)
410	409
…	…
414	413	else
415	414	SHARED_LIB_SUFFIX = so# shared lib suffix
416		LINK_SHARED_LIB := $(GPP) $(lflags) -shared $(GCOVFLAGS) -o# link shared lib
	415	LINK_SHARED_LIB := $(GPP) $(lflags) $(cdynamic) -shared $(GCOVFLAGS) -o# link shared lib
417	416	endif
418	417
…	…
691	690
692	691	# ---------------------------------------
	692	# wrap main()
	693
	694	use_ARB_main=$(ARBHOME)/SOURCE_TOOLS/arb_main_cpp.o
	695	use_ARB_main_C=$(ARBHOME)/SOURCE_TOOLS/arb_main_c.o
	696
	697	arbmainwrapper:
	698	$(MAKE) -C SOURCE_TOOLS -r "cflags = $(cflags)" mainwrapper
	699
	700	# ---------------------------------------
693	701	# List of standard top level directories
694	702	#
…	…
702	710	AISC/AISC.a \
703	711	AISC_MKPTPS/AISC_MKPTPS.a \
704		~~ALIV3/ALIV3.a \~~
705	712	ARBDB/libARBDB.a \
706	713	CORE/libCORE.a \
…	…
817	824	SL/NDS/NDS.a \
818	825	SL/ITEMS/ITEMS.a \
	826	SL/LOCATION/LOCATION.a \
819	827	SL/TRANSLATE/TRANSLATE.a \
820	828	SL/TREEDISP/TREEDISP.a \
…	…
827	835	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_NTREE) $(GUI_LIBS) \|\| ( \
828	836	echo "$(SEP) Link $@"; \
829		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_NTREE) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS)" ; \
830		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_NTREE) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS) && \
	837	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_NTREE) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS)" ; \
	838	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_NTREE) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS) && \
831	839	echo "$(SEP) Link $@ [done]"; \
832	840	)
…	…
863	871	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_EDIT4) $(GUI_LIBS) \|\| ( \
864	872	echo "$(SEP) Link $@"; \
865		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_EDIT4) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(LIBS_EDIT4) $(EXECLIBS)" ; \
866		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_EDIT4) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(LIBS_EDIT4) $(EXECLIBS) && \
	873	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_EDIT4) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(LIBS_EDIT4) $(EXECLIBS)" ; \
	874	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_EDIT4) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(LIBS_EDIT4) $(EXECLIBS) && \
867	875	echo "$(SEP) Link $@ [done]"; \
868	876	)
…	…
873	881	RNACMA/RNACMA.a \
874	882
875		$(RNACMA): $(ARCHS_RNACMA:.a=.dummy) link_db
876		@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_RNACMA) ~~$(LIBS)~~ \|\| ( \
	883	$(RNACMA) : $(ARCHS_RNACMA:.a=.dummy) link_db
	884	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_RNACMA) \|\| ( \
877	885	echo "$(SEP) Link $@"; \
878		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(~~LIBS) $(ARCHS_RNACMA) $(EXECLIBS)"~~ ; \
879		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(~~LIBS) $(ARCHS_RNACMA~~) $(EXECLIBS) && \
	886	echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_RNACMA) $(LIBS) $(EXECLIBS)"; \
	887	$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_RNACMA) $(LIBS) $(EXECLIBS) && \
880	888	echo "$(SEP) Link $@ [done]"; \
881	889	)
882
883	890
884	891	#********************************* arb_pgt ************************************
…	…
893	900	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_PGT) \|\| ( \
894	901	echo "$(SEP) Link $@"; \
895		echo "$(LINK_EXECUTABLE) $@ $(~~LIBPATH) $(ARCHS_PGT) $(PGT_SYS_LIBS) $(EXECLIBS)~~"; \
896		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PGT) $(PGT_SYS_LIBS) $(EXECLIBS) && \
	902	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PGT) $(PGT_SYS_LIBS) $(EXECLIBS) "; \
	903	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PGT) $(PGT_SYS_LIBS) $(EXECLIBS) && \
897	904	echo "$(SEP) Link $@ [done]"; \
898	905	)
…	…
910	917	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_WETC) $(GUI_LIBS) \|\| ( \
911	918	echo "$(SEP) Link $@"; \
912		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_WETC) $(GUI_LIBS) $(EXECLIBS)" ; \
913		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_WETC) $(GUI_LIBS) $(EXECLIBS) && \
	919	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_WETC) $(GUI_LIBS) $(EXECLIBS)" ; \
	920	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_WETC) $(GUI_LIBS) $(EXECLIBS) && \
914	921	echo "$(SEP) Link $@ [done]"; \
915	922	)
…	…
934	941	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_DIST) $(GUI_LIBS) \|\| ( \
935	942	echo "$(SEP) Link $@"; \
936		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_DIST) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS)" ; \
937		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_DIST) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS) && \
	943	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_DIST) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS)" ; \
	944	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_DIST) $(ARCHS_CLIENT_PROBE) $(GUI_LIBS) $(EXECLIBS) && \
938	945	echo "$(SEP) Link $@ [done]"; \
939	946	)
…	…
957	964	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_PARSIMONY) $(GUI_LIBS) \|\| ( \
958	965	echo "$(SEP) Link $@"; \
959		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PARSIMONY) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(EXECLIBS)" ; \
960		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PARSIMONY) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(EXECLIBS) && \
	966	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PARSIMONY) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(EXECLIBS)" ; \
	967	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PARSIMONY) $(ARCHS_CLIENT_NAMES) $(GUI_LIBS) $(EXECLIBS) && \
961	968	echo "$(SEP) Link $@ [done]"; \
962	969	)
…	…
968	975	SL/FILE_BUFFER/FILE_BUFFER.a \
969	976
970
971		$(CONVERT_ALN) : $(ARCHS_CONVERT_ALN:.a=.dummy) link_db
	977	$(CONVERT_ALN) : $(ARCHS_CONVERT_ALN:.a=.dummy) link_db
972	978	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_CONVERT_ALN) \|\| ( \
973	979	echo "$(SEP) Link $@"; \
974		echo "$(LINK_EXECUTABLE) $@ $(~~LIBPATH) $(ARCHS_CONVERT_ALN) $(EXECLIBS)"~~ ; \
975		$(LINK_EXECUTABLE) $@ $(~~LIBPATH) $(ARBDB_LIB) $(ARCHS_CONVERT_ALN~~) $(EXECLIBS) && \
	980	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_CONVERT_ALN) $(LIBS) $(ARBDB_LIB) $(EXECLIBS)"; \
	981	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_CONVERT_ALN) $(LIBS) $(ARBDB_LIB) $(EXECLIBS) && \
976	982	echo "$(SEP) Link $@ [done]"; \
977	983	)
978	984
979	985	#********************************* arb_treegen ************************************
	986
980	987	TREEGEN = bin/arb_treegen
981	988	ARCHS_TREEGEN = \
…	…
985	992	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_TREEGEN) \|\| ( \
986	993	echo "$(SEP) Link $@"; \
987		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_TREEGEN) $(EXECLIBS)" ; \
988		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_TREEGEN) $(EXECLIBS) && \
	994	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main_C) $(LIBPATH) $(ARCHS_TREEGEN) $(EXECLIBS)" ; \
	995	$(LINK_EXECUTABLE) $@ $(use_ARB_main_C) $(LIBPATH) $(ARCHS_TREEGEN) $(EXECLIBS) && \
989	996	echo "$(SEP) Link $@ [done]"; \
990	997	)
…	…
1000	1007	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_NALIGNER) \|\| ( \
1001	1008	echo "$(SEP) Link $@"; \
1002		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_NALIGNER) $(ARCHS_CLIENT_PROBE) $(LIBS) $(EXECLIBS)" ; \
1003		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_NALIGNER) $(ARCHS_CLIENT_PROBE) $(LIBS) $(EXECLIBS) && \
	1009	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_NALIGNER) $(ARCHS_CLIENT_PROBE) $(LIBS) $(EXECLIBS)" ; \
	1010	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_NALIGNER) $(ARCHS_CLIENT_PROBE) $(LIBS) $(EXECLIBS) && \
1004	1011	echo "$(SEP) Link $@ [done]"; \
1005	1012	)
…	…
1017	1024	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_PHYLO) $(GUI_LIBS) \|\| ( \
1018	1025	echo "$(SEP) Link $@"; \
1019		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PHYLO) $(GUI_LIBS) $(EXECLIBS)" ; \
1020		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PHYLO) $(GUI_LIBS) $(EXECLIBS) && \
	1026	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PHYLO) $(GUI_LIBS) $(EXECLIBS)" ; \
	1027	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PHYLO) $(GUI_LIBS) $(EXECLIBS) && \
1021	1028	echo "$(SEP) Link $@ [done]"; \
1022	1029	)
…	…
1035	1042	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_DBSERVER) $(ARBDB_LIB) \|\| ( \
1036	1043	echo "$(SEP) Link $@"; \
1037		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_DBSERVER) $(ARBDB_LIB) PROBE_COM/client.a $(SYSLIBS) $(EXECLIBS)" ; \
1038		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_DBSERVER) $(ARBDB_LIB) PROBE_COM/client.a $(SYSLIBS) $(EXECLIBS) && \
	1044	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_DBSERVER) $(ARBDB_LIB) PROBE_COM/client.a $(SYSLIBS) $(EXECLIBS)" ; \
	1045	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_DBSERVER) $(ARBDB_LIB) PROBE_COM/client.a $(SYSLIBS) $(EXECLIBS) && \
1039	1046	echo "$(SEP) Link $@ [done]"; \
1040	1047	)
…	…
1058	1065	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_PROBE_LINK) $(ARBDB_LIB) $(ARCHS_CLIENT_PROBE) config.makefile \|\| ( \
1059	1066	echo "$(SEP) Link $@"; \
1060		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PROBE_LINK) $(ARBDB_LIB) $(ARCHS_CLIENT_PROBE) PROBE_COM/server.a $(SYSLIBS) $(EXECLIBS)" ; \
1061		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_PROBE_LINK) $(ARBDB_LIB) $(ARCHS_CLIENT_PROBE) PROBE_COM/server.a $(SYSLIBS) $(EXECLIBS) && \
	1067	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PROBE_LINK) $(ARBDB_LIB) $(ARCHS_CLIENT_PROBE) PROBE_COM/server.a $(SYSLIBS) $(EXECLIBS)" ; \
	1068	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_PROBE_LINK) $(ARBDB_LIB) $(ARCHS_CLIENT_PROBE) PROBE_COM/server.a $(SYSLIBS) $(EXECLIBS) && \
1062	1069	echo "$(SEP) Link $@ [done]"; \
1063	1070	)
…	…
1072	1079	@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_NAMES) $(ARBDB_LIB) $(ARCHS_CLIENT_NAMES) \|\| ( \
1073	1080	echo "$(SEP) Link $@"; \
1074		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_NAMES) $(ARBDB_LIB) $(ARCHS_CLIENT_NAMES) NAMES_COM/server.a $(SYSLIBS) $(EXECLIBS)" ; \
1075		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_NAMES) $(ARBDB_LIB) $(ARCHS_CLIENT_NAMES) NAMES_COM/server.a $(SYSLIBS) $(EXECLIBS) && \
1076		echo "$(SEP) Link $@ [done]"; \
1077		)
1078
1079		#********************************* OTHER EXECUTABLES ******************************************
1080
1081		ALIV3 = bin/aliv3
1082		ARCHS_ALIV3 = \
1083		ALIV3/ALIV3.a \
1084		SL/HELIX/HELIX.a \
1085
1086		$(ALIV3): $(ARCHS_ALIV3:.a=.dummy) link_db
1087		@SOURCE_TOOLS/binuptodate.pl $@ $(ARCHS_ALIV3) $(ARBDB_LIB) \|\| ( \
1088		echo "$(SEP) Link $@"; \
1089		echo "$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_ALIV3) $(ARBDB_LIB) $(SYSLIBS) $(EXECLIBS)"; \
1090		$(LINK_EXECUTABLE) $@ $(LIBPATH) $(ARCHS_ALIV3) $(ARBDB_LIB) $(SYSLIBS) $(EXECLIBS) && \
	1081	echo "$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_NAMES) $(ARBDB_LIB) $(ARCHS_CLIENT_NAMES) NAMES_COM/server.a $(SYSLIBS) $(EXECLIBS)" ; \
	1082	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $(LIBPATH) $(ARCHS_NAMES) $(ARBDB_LIB) $(ARCHS_CLIENT_NAMES) NAMES_COM/server.a $(SYSLIBS) $(EXECLIBS) && \
1091	1083	echo "$(SEP) Link $@ [done]"; \
1092	1084	)
…	…
1195	1187	AWT/libAWT.dummy: links_non_perl
1196	1188	AWTI/AWTI.dummy: links_non_perl
1197		~~ALIV3/ALIV3.dummy: links_non_perl~~
1198	1189	CONSENSUS_TREE/CONSENSUS_TREE.dummy: links_non_perl
1199	1190	DBSERVER/DBSERVER.dummy: links_non_perl
…	…
1363	1354
1364	1355	nal: $(NALIGNER)
1365		~~a3: $(ALIV3)~~
1366	1356
1367	1357	di: $(DIST)
…	…
1452	1442	$(ARCHS_PT_SERVER:.a=.proto) \
1453	1443	SERVERCNTRL/SERVERCNTRL.proto \
1454		~~GDE/GDE.proto \~~
1455	1444	SL/SL.proto \
1456	1445
…	…
1500	1489	LINKSTAMP=SOURCE_TOOLS/stamp.generate_all_links
1501	1490
1502		links: checks $(LINKSTAMP)
	1491	links: checks $(LINKSTAMP) arbmainwrapper
1503	1492
1504	1493	forcelinks:
…	…
1793	1782	arbapplications: nt pa e4 wetc pt na nal di ph ds pgt wetc cma
1794	1783
1795		arb_external: convert tools gde readseq tg pst a3 xmlin
	1784	arb_external: convert tools gde readseq tg pst xmlin
1796	1785
1797	1786	arb_no_perl: arbapplications help arb_external
…	…
1813	1802	rac_arb_db_server: ds
1814	1803	rac_arb_name_server: na
1815		~~rac_aliv3: a3~~
1816	1804	rac_arb_pgt: pgt
1817	1805	rac_arb_convert_aln: convert
…	…
1835	1823	UNITS_WORKING = \
1836	1824	$(RNA3D_TEST) \
1837		~~ALIV3/ALIV3.test \~~
1838	1825	ARB_GDE/ARB_GDE.test \
	1826	AWTI/AWTI.test \
1839	1827	CONSENSUS_TREE/CONSENSUS_TREE.test \
1840	1828	DIST/DIST.test \
1841	1829	EISPACK/EISPACK.test \
1842	1830	GENOM/GENOM.test \
	1831	GENOM_IMPORT/GENOM_IMPORT.test \
1843	1832	GL/glAW/libglAW.test \
1844	1833	GL/glpng/libglpng_arb.test \
…	…
1851	1840	PRIMER_DESIGN/PRIMER_DESIGN.test \
1852	1841	PROBE_DESIGN/PROBE_DESIGN.test \
1853		~~ptpan/PROBE.test \~~
1854	1842	SECEDIT/SECEDIT.test \
1855	1843	SEQ_QUALITY/SEQ_QUALITY.test \
…	…
1867	1855	SL/HELIX/HELIX.test \
1868	1856	SL/ITEMS/ITEMS.test \
	1857	SL/LOCATION/LOCATION.test \
1869	1858	SL/MATRIX/MATRIX.test \
1870	1859	SL/NDS/NDS.test \
…	…
1883	1872	# untestable units
1884	1873
1885		~~UNITS_TRY_FIX = \~~
1886
1887	1874	UNITS_NEED_FIX = \
1888		~~AWTI/AWTI~~.test \
	1875	ptpan/PROBE.test \
1889	1876
1890	1877	UNITS_UNTESTABLE_ATM = \
…	…
1902	1889	UNITS_TESTED = \
1903	1890	DBSERVER/DBSERVER.test \
1904		~~GENOM_IMPORT/GENOM_IMPORT.test \~~
1905	1891	AWT/AWT.test \
1906	1892	CORE/CORE.test \
…	…
1922	1908
1923	1909	TESTED_UNITS_MANUAL = \
1924		~~$(UNITS_TRY_FIX) \~~
1925	1910	$(UNITS_TESTED_FIRST) \
1926	1911	$(UNITS_TESTED) \
1927	1912
1928	1913	# $(UNITS_WORKING)
	1914
	1915	# see UNIT_TESTER/sym2testcode.pl@disableErrorOnUnitsWithoutTests
1929	1916
1930	1917	#TESTED_UNITS = $(TESTED_UNITS_AUTO)

branches/e4fix/NALIGNER/ali_global.cxx

r8190	r8274
60	60
61	61
62		void ALI_GLOBAL::init(int argc, char argv[])
	62	void ALI_GLOBAL::init(int argc, const char argv[])
63	63	{
64	64	int kill, i, h, j, ret;
65		char *pos;
	65	const char *pos;
66	66	arb_params *params;
67	67	float fl;

branches/e4fix/NALIGNER/ali_global.hxx

r7811	r8274
21	21
22	22	// misc
23		c~~har~~ *prog_name;
24		char *species_name;
25		char *default_file;
26		char *db_server;
27		char *pt_server;
	23	const char *prog_name;
	24	char *species_name;
	25	char *default_file;
	26	char *db_server;
	27	char *pt_server;
28	28
29	29	// other classes
…	…
45	45
46	46	// functions
47		void init(int argc, char argv[]);
	47	void init(int argc, const char argv[]);
48	48	};
49	49

branches/e4fix/NALIGNER/ali_main.cxx

r8190	r8274
216	216
217	217
218		int main(int argc, char **argv)
219		{
	218	int ARB_main(int argc, const char *argv[]) {
220	219	int i;
221	220	char message_buffer[100];

branches/e4fix/NALIGNER/ali_prealigner.cxx

r8190	r8274
230	230
231	231	inline void ALI_PREALIGNER::calculate_first_column_first_cell(ali_prealigner_cell * akt_cell) {
232		float v1, v2~~, v3~~;
	232	float v1, v2;
233	233
234	234	v1 = profile->w_ins_multi_cheap(start_x, start_y) + profile->w_sub_multi_gap_cheap(start_y, start_y);
235	235	v2 = profile->w_sub(start_y, start_x);
236		~~v3 = v1;~~
237	236
238	237	akt_cell->d = minimum2(v1, v2);
…	…
413	412	// Generate a sub_solution by deleting all undefined segments
414	413	ALI_MAP *seg_map;
415		unsigned long map_pos~~, map_len~~;
	414	unsigned long map_pos;
416	415	unsigned long start_seg, end_seg, pos_seg;
417	416
418	417	sub_solution = new ALI_SUB_SOLUTION(profile);
419	418
420		~~map_len = map->last_base() - map->first_base() + 1;~~
421	419	for (map_pos = map->first_base(); map_pos <= map->last_base(); map_pos++) {
422	420	// search for segment

branches/e4fix/NAMES/names.cxx

r8103	r8274
1161	1161	}
1162	1162
1163		int main(int argc, char **argv)
1164		{
	1163	int ARB_main(int argc, const char *argv[]) {
1165	1164	char *name;
1166	1165	int i;
…	…
1168	1167	arb_params *params;
1169	1168
1170		params = arb_trace_argv(&argc, argv);
	1169	params = arb_trace_argv(&argc, (const char **)argv);
1171	1170	const char *executable = argv[0];
1172	1171

branches/e4fix/NTREE/AP_cprofile.cxx

r7811	r8274
228	228	{
229	229	long base;
230		long column, ~~colmax,~~ memneeded=0;
	230	long column, memneeded=0;
231	231	long sum, hits, different, group;
232	232	long hitsc, diffc, groupc;
…	…
249	249	{
250	250	CPRO.result[which_statistic].maxaccu=sum;
251		~~colmax=column;~~
252	251	}
253	252	}
…	…
636	635	static void CPRO_memrequirement_cb(AW_root *aw_root)
637	636	{
638		~~char versus = 0; // all vs all~~
639		{
640		~~char *marked = aw_root->awar("cpro/which_species")->read_string();~~
641
642		~~if (!(strcmp("marked", marked))) versus = 1;~~
643		~~if (!(strcmp("markedall", marked))) versus = 2;~~
644		~~free(marked);~~
645		}
646
647	637	CPRO.partition = aw_root->awar("cpro/partition")->read_int();
648	638	long resolution = aw_root->awar("cpro/resolution")->read_int();

branches/e4fix/NTREE/NT_extern.cxx

r8103	r8274
478	478
479	479	static AWT_config_mapping_def tree_setting_config_mapping[] = {
480		{ AWAR_DTREE_BASELINEWIDTH, "line_width" },
481		{ AWAR_DTREE_VERICAL_DIST, "vert_dist" },
482		{ AWAR_DTREE_AUTO_JUMP, "auto_jump" },
483		{ AWAR_DTREE_SHOW_CIRCLE, "show_circle" },
484		{ AWAR_DTREE_SHOW_BRACKETS, "show_brackets" },
485		{ AWAR_DTREE_USE_ELLIPSE, "use_ellipse" },
486		{ AWAR_DTREE_CIRCLE_ZOOM, "circle_zoom" },
487		{ AWAR_DTREE_CIRCLE_MAX_SIZE, "circle_max_size" },
488		{ AWAR_DTREE_GREY_LEVEL, "grey_level" },
	480	{ AWAR_DTREE_BASELINEWIDTH, "line_width" },
	481	{ AWAR_DTREE_VERICAL_DIST, "vert_dist" },
	482	{ AWAR_DTREE_AUTO_JUMP, "auto_jump" },
	483	{ AWAR_DTREE_SHOW_CIRCLE, "show_circle" },
	484	{ AWAR_DTREE_SHOW_BRACKETS, "show_brackets" },
	485	{ AWAR_DTREE_USE_ELLIPSE, "use_ellipse" },
	486	{ AWAR_DTREE_CIRCLE_ZOOM, "circle_zoom" },
	487	{ AWAR_DTREE_CIRCLE_MAX_SIZE, "circle_max_size" },
	488	{ AWAR_DTREE_GREY_LEVEL, "grey_level" },
	489	{ AWAR_DTREE_DENDRO_ZOOM_TEXT, "dendro_zoomtext" },
	490	{ AWAR_DTREE_DENDRO_XPAD, "dendro_xpadding" },
	491	{ AWAR_DTREE_RADIAL_ZOOM_TEXT, "radial_zoomtext" },
	492	{ AWAR_DTREE_RADIAL_XPAD, "radial_xpadding" },
489	493	{ 0, 0 }
490	494	};
…	…
554	558	aws->label("Grey Level of Groups%");
555	559	aws->create_input_field(AWAR_DTREE_GREY_LEVEL, 4);
	560	aws->at_newline();
	561
	562	aws->label("Text zoom/pad (dendro)");
	563	aws->create_toggle(AWAR_DTREE_DENDRO_ZOOM_TEXT);
	564	aws->create_input_field(AWAR_DTREE_DENDRO_XPAD, 4);
	565	aws->at_newline();
	566
	567	aws->label("Text zoom/pad (radial)");
	568	aws->create_toggle(AWAR_DTREE_RADIAL_ZOOM_TEXT);
	569	aws->create_input_field(AWAR_DTREE_RADIAL_XPAD, 4);
556	570	aws->at_newline();
557	571
…	…
1126	1140	{
1127	1141	AP_tree_sort old_sort_type = GLOBAL_NT.tree->tree_sort;
1128		GLOBAL_NT.tree->set_tree_type(AP_LIST_SIMPLE); // avoid NDS warnings during startup
	1142	GLOBAL_NT.tree->set_tree_type(AP_LIST_SIMPLE, NULL); // avoid NDS warnings during startup
1129	1143
1130	1144	ntw = new AWT_canvas(GLOBAL_gb_main, awm, GLOBAL_NT.tree, aw_gc_manager, awar_tree);
1131		GLOBAL_NT.tree->set_tree_type(old_sort_type);
	1145	GLOBAL_NT.tree->set_tree_type(old_sort_type, ntw);
1132	1146	ntw->set_mode(AWT_MODE_SELECT);
1133	1147	}
…	…
1143	1157	else {
1144	1158	AW_advice("Your database contains no tree.", AW_ADVICE_TOGGLE\|AW_ADVICE_HELP, 0, "no_tree.hlp");
1145		GLOBAL_NT.tree->set_tree_type(AP_LIST_NDS); // no tree -> show NDS list
	1159	GLOBAL_NT.tree->set_tree_type(AP_LIST_NDS, ntw); // no tree -> show NDS list
1146	1160	}
1147	1161
…	…
1160	1174	awr->awar(AWAR_DTREE_CIRCLE_MAX_SIZE)->add_callback((AW_RCB)AWT_expose_cb, (AW_CL)ntw, 0);
1161	1175	awr->awar(AWAR_DTREE_USE_ELLIPSE)->add_callback((AW_RCB)AWT_expose_cb, (AW_CL)ntw, 0);
	1176
	1177	awr->awar(AWAR_DTREE_RADIAL_ZOOM_TEXT)->add_callback((AW_RCB)NT_reinit_treetype, (AW_CL)ntw, 0);
	1178	awr->awar(AWAR_DTREE_RADIAL_XPAD)->add_callback((AW_RCB)NT_reinit_treetype, (AW_CL)ntw, 0);
	1179	awr->awar(AWAR_DTREE_DENDRO_ZOOM_TEXT)->add_callback((AW_RCB)NT_reinit_treetype, (AW_CL)ntw, 0);
	1180	awr->awar(AWAR_DTREE_DENDRO_XPAD)->add_callback((AW_RCB)NT_reinit_treetype, (AW_CL)ntw, 0);
	1181
1162	1182	awr->awar(AWAR_TREE_REFRESH)->add_callback((AW_RCB)AWT_expose_cb, (AW_CL)ntw, 0);
1163	1183	awr->awar(AWAR_COLOR_GROUPS_USE)->add_callback((AW_RCB)NT_recompute_cb, (AW_CL)ntw, 0);

branches/e4fix/NTREE/NT_main.cxx

r8103	r8274
515	515	}
516	516
517		int ~~main(int argc, char **argv~~) {
	517	int ARB_main(int argc, const char *argv[]) {
518	518	aw_initstatus();
519	519	GB_set_verbose();

branches/e4fix/NTREE/NT_validNameParser.cxx

r6385	r8274
77	77	bool isHomo = false;
78	78	bool isGenus = false;
79		bool isSee = false;
	79	// bool isSee = false;
80	80	bool isCorr = false;
81	81
…	…
134	134	else {
135	135	if (*it == string("see:")) {
136		isSee = true;
	136	// isSee = true;
137	137	isValid = false;
138	138	#if defined(DUMP)

branches/e4fix/PARSIMONY/PARS_main.cxx

r8037	r8274
1262	1262	{
1263	1263	AP_tree_sort old_sort_type = GLOBAL_PARS->tree->tree_sort;
1264		GLOBAL_PARS->tree->set_tree_type(AP_LIST_SIMPLE); // avoid NDS warnings during startup
	1264	GLOBAL_PARS->tree->set_tree_type(AP_LIST_SIMPLE, NULL); // avoid NDS warnings during startup
1265	1265	ntw = new AWT_canvas(GLOBAL_gb_main, (AW_window *)awm, GLOBAL_PARS->tree, aw_gc_manager, AWAR_TREE);
1266		GLOBAL_PARS->tree->set_tree_type(old_sort_type);
	1266	GLOBAL_PARS->tree->set_tree_type(old_sort_type, ntw);
1267	1267	}
1268	1268
…	…
1661	1661	}
1662	1662
1663		int ~~main(int argc, char **argv~~) {
	1663	int ARB_main(int argc, const char *argv[]) {
1664	1664	aw_initstatus();
1665	1665

branches/e4fix/PGT/help_dialog.cxx

r3978	r8274
81	81	// USED PIXMAPS (BUTTON LOGOS)
82	82	Pixmap circle22_xpm, cross22_xpm, text22_xpm, markonly22_xpm, textonly22_xpm,
83		markall22_xpm, marknone22_xpm, arb2mark_xpm, mark2arb_xpm, ~~help_xpm,~~
	83	markall22_xpm, marknone22_xpm, arb2mark_xpm, mark2arb_xpm,
84	84	markinfo22_xpm, markinvert22_xpm;
85	85
…	…
97	97	arb2mark_xpm = PGT_LoadPixmap("arb2mark22.xpm", s, fg, bg);
98	98	mark2arb_xpm = PGT_LoadPixmap("mark2arb22.xpm", s, fg, bg);
99		~~help_xpm = PGT_LoadPixmap("help22.xpm", s, fg, bg);~~
100	99
101	100	// CREATE A SIMPLE LABEL

branches/e4fix/PGT/image_dialog.cxx

r7190	r8274
2326	2326	bool imageDialog::updateSelectedGene()
2327	2327	{
2328		char awar_selected_protein, awar_gene_id, *name= NULL;
	2328	char awar_selected_protein, name= NULL;
2329	2329	GBDATA gb_genome, gb_gene, *gb_name;
2330	2330
…	…
2335	2335	// FETCH PROTEIN AWAR CONTENT
2336	2336	awar_selected_protein= get_protein_AWAR();
2337
2338		~~// FETCH GENE IDENTIFIER~~
2339		~~awar_gene_id= get_CONFIG(CONFIG_PGT_ID_GENE);~~
2340	2337
2341	2338	// FETCH GENE

branches/e4fix/PGT/main.cxx

r7623	r8274
33	33	bool DB_Connect();
34	34	void DB_Disconnect();
35		int Run(int, char **);
	35	int Run(int, const char **);
36	36	protected:
37	37	void MainLoop();
…	…
145	145	-1 = AN ERROR OCCURRED (UNABLE TO ESTABLISH DB CONNECTION)
146	146	****************************************************************************/
147		int CMain::Run(int argc, char **argv)
	147	int CMain::Run(int argc, const char **argv)
148	148	{
149	149	// TRY TO ESTABLISH THE DATABASE CONNECTIONS
…	…
160	160	// CREATE THE TOP LEVEL WIDGET (APPLICATION WIDGET)
161	161	m_topwidget= XtVaOpenApplication(&m_xapp, "PGTApp", NULL, 0,
162		~~&argc,~~ argv, NULL,
163		sessionShellWidgetClass,
164		NULL);
	162	&argc, (char**)argv, NULL,
	163	sessionShellWidgetClass,
	164	NULL);
165	165
166	166	// CREATE THE PGT MAIN DIALOG WINDOW
…	…
183	183	* MAIN FUNCTION - NO FURTHER COMMENT NECESSARY... ;-)
184	184	****************************************************************************/
185		int main(int argc, char **argv)
186		{
	185	int ARB_main(int argc, const char *argv[]) {
187	186	// CREATE THE PGT MAIN EVENT HANDLER
188	187	CMain cmain;

branches/e4fix/PHYLO/PH_display.cxx

r7661	r8274
209	209
210	210	if (!device) return;
211		~~if (!markerline) return;~~
212	211
213	212	GB_transaction dummy(PHDATA::ROOT->gb_main);

branches/e4fix/PHYLO/PH_main.cxx

r8036	r8274
57	57	}
58	58
59		void startup_sequence_cb(AW_window *aww, AW_CL cd1, AW_CL cl_aww)
60		{
61		PHDATA *phd;
62		char use, load_what;
63		AW_root *aw_root;
64
	59	void startup_sequence_cb(AW_window *aww, AW_CL cd1, AW_CL cl_aww) {
65	60	if (aww) aww->hide();
66		~~aw_root=~~(AW_root *) cd1;
	61	AW_root aw_root = (AW_root ) cd1;
67	62	// loading database
68	63	GB_push_transaction(GLOBAL_gb_main);
…	…
72	67	GB_pop_transaction(GLOBAL_gb_main);
73	68
74		use = aw_root->awar("phyl/alignment")->read_string();
75		~~load_what = aw_root->awar("phyl/which_species")->read_string(); // all, marked ...~~
76		phd=new PHDATA(aw_root);
	69	char *use = aw_root->awar("phyl/alignment")->read_string();
	70	PHDATA *phd = new PHDATA(aw_root);
	71
77	72	GB_set_cache_size(GLOBAL_gb_main, PH_DB_CACHE_SIZE);
78	73	phd->load(use);
79	74	phd->ROOT = phd;
	75
80	76	long len = PHDATA::ROOT->get_seq_len();
81	77	aw_root->awar("phyl/filter/stopcol")->write_int(len);
…	…
535	531
536	532
537		int ~~main(int argc, char **argv~~) {
	533	int ARB_main(int argc, const char *argv[]) {
538	534	if (argc > 2 \|\| (argc == 2 && strcmp(argv[1], "--help") == 0)) {
539	535	fprintf(stderr, "Usage: arb_phylo [database]\n");

branches/e4fix/PROBE/PT_buildtree.cxx

r8103	r8274
393	393	#endif
394	394
395		~~int main(int argc, const char*argv[]);~~
396	395	void NOTEST_SLOW_maybe_build_tree() {
397	396	// does only test sth if DB is present.
…	…
412	411	#if 1
413	412	// build
414		int res = main(ARRAY_ELEMS(argv), argv);
	413	int res = ARB_main(ARRAY_ELEMS(argv), argv);
415	414	TEST_ASSERT_EQUAL(res, EXIT_SUCCESS);
416	415	#endif

branches/e4fix/PROBE/PT_main.cxx

r8103	r8274
469	469	}
470	470
471		int ~~main(int argc, char **argv~~) {
	471	int ARB_main(int argc, const char *argv[]) {
472	472	int exitcode = EXIT_SUCCESS;
473		arb_params *params = arb_trace_argv(&argc, argv);
	473	arb_params params = arb_trace_argv(&argc, (const char *)argv);
474	474	const char *exename = argv[0];
475	475

branches/e4fix/PROBE/PT_prefixtree.cxx

r8103	r8274
756	756
757	757	POS_TREE *sons;
758		long r_pos, r_poss[PT_B_MAX], ~~son_size[PT_B_MAX],~~ o_pos;
	758	long r_pos, r_poss[PT_B_MAX], o_pos;
759	759	int block[10]; // TODO: check why we allocate 10 ints when only block[0] is used
760	760	int i;
…	…
785	785	r_pos = PTD_write_leafs_to_disk(out, sons, pos, &(r_poss[i]), &(block[0]), error);
786	786	if (r_pos>pos) { // really saved ????
787		~~son_size[i] = r_pos-pos;~~
788	787	pos = r_pos;
789	788	}
790		~~else {~~
791		~~son_size[i] = 0;~~
792		}
793		}
794		~~else {~~
795		~~son_size[i] = 0;~~
796	789	}
797	790	}
…	…
871	864	}
872	865
873		#ifndef ARB_64
	866	#ifdef ARB_64
	867	// 64bit version:
	868	big_db = big_db; // only used in 32bit
	869	info_detected = info_detected;
	870	#else
874	871	// 32bit version:
875	872	if (!error && big_db) {
…	…
879	876	printf("Warning: ptserver DB has old format (no problem)\n");
880	877	}
881		#endif ~~// ARB_64~~
	878	#endif
882	879
883	880	if (!error) {

branches/e4fix/PROBE/pt_prototypes.h

r8041	r8274
57	57	void PT_exit(void);
58	58	GB_ERROR PT_init_map(void) __ATTR__USERESULT;
	59	int ARB_main(int argc, const char *argv[]);
59	60
60	61	/* PT_match.cxx */

branches/e4fix/PROBE_DESIGN/probe_design.cxx

r8103	r8274
310	310
311	311	for (GBDATA *gb_species = GEN_first_organism(gb_main); gb_species && !error; gb_species = GEN_next_organism(gb_species)) {
312		~~const char *sequence = 0;~~
313	312	const char *species_name = 0;
314	313	{
315	314	GBDATA *gb_data = GBT_read_sequence(gb_species, use);
316	315	if (!gb_data) { error = species_requires(gb_species, GBS_global_string("data in '%s'", use)); break; }
317		~~sequence = GB_read_char_pntr(gb_data);~~
318	316
319	317	GBDATA *gb_name = GB_search(gb_species, "name", GB_FIND);

branches/e4fix/PROBE_SET/ps_convert_db.cxx

r6385	r8274
189	189	char *_argv[]) {
190	190
191		GBDATA *~~ARB~~_main = 0;
	191	GBDATA *gb_main = 0;
192	192	GB_ERROR error = 0;
193	193
…	…
207	207	times(&before);
208	208	printf("Opening probe-group-database '%s'..\n ", DB_name);
209		~~ARB~~_main = GB_open(DB_name, "rwcN");
210		if (!~~ARB~~_main) {
	209	gb_main = GB_open(DB_name, "rwcN");
	210	if (!gb_main) {
211	211	error = GB_await_error();
212	212	GB_warning(error);
…	…
216	216	PS_print_time_diff(&before);
217	217
218		GB_transaction dummy(~~ARB~~_main);
219		GBDATA *group_tree = GB_entry(~~ARB~~_main, "group_tree");
	218	GB_transaction dummy(gb_main);
	219	GBDATA *group_tree = GB_entry(gb_main, "group_tree");
220	220	if (!group_tree) {
221	221	printf("no 'group_tree' in database\n");
…	…
235	235	times(&before);
236	236	printf("init Species <-> ID - Map\n");
237		PG_initSpeciesMaps(~~ARB~~_main);
	237	PG_initSpeciesMaps(gb_main);
238	238	int species_count = PG_NumberSpecies();
239	239	printf("%i species in the map ", species_count);

branches/e4fix/PROBE_SET/ps_my2asciipaths.cxx

r6385	r8274
14	14	// GLOBALS
15	15
16		typedef pair<bool, SpeciesID> p;
17		vector<~~p> *__PATH = new vector<~~p>;
	16	typedef pair<bool, SpeciesID> Step;
	17	vector<Step> *__PATH = new vector<Step>;
18	18
19	19	void PS_print_paths(const PS_NodePtr _ps_node) {
…	…
21	21
22	22	// path
23		__PATH->push_back(p(_ps_node->hasInverseProbes(), _ps_node->hasProbes() ? _ps_node->getNum() : -(_ps_node->getNum())));
	23	__PATH->push_back(Step(_ps_node->hasInverseProbes(), _ps_node->hasProbes() ? _ps_node->getNum() : -(_ps_node->getNum())));
24	24
25	25	// children
…	…
32	32	// print path in leaf nodes
33	33	printf("[%4zu] ", __PATH->size());
34		for (vector<p>::const_iterator i=__PATH->begin(); i != __PATH->end(); ++i) {
	34	for (vector<Step>::const_iterator i=__PATH->begin(); i != __PATH->end(); ++i) {
35	35	printf("%4i%c ", i->second, i->first ? '+' : ' ');
36	36	}

branches/e4fix/RNA3D/RNA3D_Interface.cxx

r7931	r8274
94	94
95	95	void KeyPressEventHandler(Widget /* w /, XtPointer / client_data /, XEvent event, char* /* x */) {
96		~~XKeyEvent *evt;~~
97		~~evt = (XKeyEvent*) event;~~
98
99	96	char buffer[1];
100	97	KeySym keysym;
101		~~int count;~~
102	98
103	99	// Converting keycode to keysym
104		~~count =~~ XLookupString((XKeyEvent *) event, buffer, 1, &keysym, NULL);
	100	XLookupString((XKeyEvent *) event, buffer, 1, &keysym, NULL);
105	101
106	102	switch (keysym) {

branches/e4fix/RNA3D/RNA3D_OpenGLEngine.cxx

r7811	r8274
206	206
207	207	void ComputeRotationXY(int x, int y) {
208		~~GLfloat dx, dy;~~
209		~~dx = RNA3D->saved_x - x;~~
210		~~dy = RNA3D->saved_y - y;~~
211	208	rot_y = (GLfloat)(x - RNA3D->saved_x) * RNA3D->ROTATION_SPEED;
212	209	rot_x = (GLfloat)(y - RNA3D->saved_y) * RNA3D->ROTATION_SPEED;

branches/e4fix/SECEDIT/SEC_paint.cxx

r7668	r8274
257	257
258	258	const BI_ecoli_ref *ecoli = db->ecoli();
259		for (size_t ep = bio2info(100); ep < ecoli->base_count(); ep += 100) {
	259	for (size_t ep = bio2info(100); ep < (size_t)ecoli->base_count(); ep += 100) {
260	260	abspos = ecoli->rel_2_abs(ep);
261	261	paintPosAnnotation(device, SEC_GC_ECOLI, size_t(abspos), GBS_global_string("%i", info2bio(ep)), true, true);

branches/e4fix/SEQ_QUALITY/SQ_functions.cxx

r7811	r8274
113	113
114	114	GBDATA *gb_species;
115		~~GBDATA *gb_species_data;~~
116	115	GBDATA *gb_name;
117	116	GBDATA (getFirst)(GBDATA *) = 0;
…	…
119	118
120	119	GB_push_transaction(gb_main);
121		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
122	120	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
123	121
…	…
126	124	getNext = GBT_next_marked_species;
127	125
128		for (gb_species = getFirst(gb_main); gb_species; gb_species
129		= getNext(gb_species)) {
	126	for (gb_species = getFirst(gb_main); gb_species; gb_species = getNext(gb_species)) {
130	127	gb_name = GB_entry(gb_species, "name");
131	128
…	…
153	150	GBDATA *read_sequence = 0;
154	151	GBDATA *gb_species;
155		~~GBDATA *gb_species_data;~~
156	152	GBDATA *gb_name;
157	153	GBDATA (getFirst)(GBDATA *) = 0;
…	…
159	155
160	156	GB_push_transaction(gb_main);
161		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
162	157	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
163	158
…	…
166	161	getNext = GBT_next_marked_species;
167	162
168		for (gb_species = getFirst(gb_main); gb_species; gb_species
169		= getNext(gb_species)) {
	163	for (gb_species = getFirst(gb_main); gb_species; gb_species = getNext(gb_species)) {
170	164	gb_name = GB_entry(gb_species, "name");
171	165	if (gb_name) {
…	…
198	192
199	193	GBDATA *gb_species;
200		~~GBDATA *gb_species_data;~~
201	194	GBDATA *gb_name;
202	195	GBDATA (getFirst)(GBDATA *) = 0;
…	…
205	198
206	199	GB_push_transaction(gb_main);
207		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
208	200	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
209	201
…	…
217	209	}
218	210
219		for (gb_species = getFirst(gb_main); gb_species && !error; gb_species
220		= getNext(gb_species)) {
	211	for (gb_species = getFirst(gb_main); gb_species && !error; gb_species = getNext(gb_species)) {
221	212	gb_name = GB_entry(gb_species, "name");
222	213
…	…
416	407	GBDATA *read_sequence = 0;
417	408	GBDATA *gb_species;
418		~~GBDATA *gb_species_data;~~
419	409	GBDATA *gb_name;
420	410	GB_ERROR error = 0;
421	411
422	412	GB_push_transaction(gb_main);
423		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
424	413	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
425	414	gb_species = node->gb_node;
426	415	gb_name = GB_entry(gb_species, "name");
427	416
428		if (!gb_name)
429		error = GB_get_error();
	417	if (!gb_name) error = GB_get_error();
430	418	else {
431	419	GBDATA *gb_ali = GB_entry(gb_species, alignment_name);
…	…
505	493	GBDATA *read_sequence = 0;
506	494	GBDATA *gb_species;
507		~~GBDATA *gb_species_data;~~
508	495	GBDATA *gb_name;
509	496	GBDATA (getFirst)(GBDATA *) = 0;
…	…
512	499
513	500	GB_push_transaction(gb_main);
514		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
515	501	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
516	502
…	…
597	583	GBDATA *read_sequence = 0;
598	584	GBDATA *gb_species;
599		~~GBDATA *gb_species_data;~~
600	585	GBDATA *gb_name;
601	586	GB_ERROR error = 0;
602	587
603	588	GB_push_transaction(gb_main);
604		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
605	589	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
606	590	gb_species = node->gb_node;
607	591	gb_name = GB_entry(gb_species, "name");
608	592
609		if (!gb_name)
610		error = GB_get_error();
	593	if (!gb_name) error = GB_get_error();
611	594	else {
612	595	GBDATA *gb_ali = GB_entry(gb_species, alignment_name);
…	…
814	797	GBDATA *read_sequence = 0;
815	798	GBDATA *gb_species;
816		~~GBDATA *gb_species_data;~~
817	799	GBDATA *gb_name;
818	800	GBDATA (getFirst)(GBDATA *) = 0;
…	…
821	803
822	804	GB_push_transaction(gb_main);
823		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
824	805	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
825	806	getFirst = GBT_first_species;
…	…
1097	1078	GBDATA *read_sequence = 0;
1098	1079	GBDATA *gb_species;
1099		~~GBDATA *gb_species_data;~~
1100	1080	GB_ERROR error = 0;
1101	1081
1102	1082	GB_push_transaction(gb_main);
1103		~~gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);~~
1104	1083	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
1105	1084

branches/e4fix/SERVERCNTRL/servercntrl.cxx

r8103	r8274
313	313	}
314	314
315		arb_params arb_trace_argv(int argc, char **argv)
	315	arb_params arb_trace_argv(int argc, const char **argv)
316	316	{
317	317	int s, d;
…	…
350	350	case 'P': freedup(erg->pt_server, argv[s]+2); break;
351	351	case 'T': {
352		char *ipport = argv[s]+2;
	352	const char *ipport = argv[s]+2;
353	353	if (ipport[0] == ':' &&
354	354	ipport[1] >= '0' && ipport[1] <= '9') { // port only -> assume localhost

branches/e4fix/SERVERCNTRL/servercntrl.h

r8100	r8274
36	36	GB_ERROR arb_look_and_kill_server(int magic_number, const char *arb_tcp_env);
37	37	void arb_print_server_params(void);
38		arb_params arb_trace_argv(int argc, char **argv);
	38	arb_params arb_trace_argv(int argc, const char **argv);
39	39	void free_arb_params(arb_params *params);
40	40

branches/e4fix/SH/README

r7488	r8274
29	29	arb_phyml wrapper for phyml
30	30	arb_proml wrapper for proml
31		~~arb_protml wrapper for protml~~
32	31	arb_protpars wrapper for protpars
33	32	arb_raxml wrapper for raxml

branches/e4fix/SH/arb_installubuntu4arb.sh

r7489	r8274
4	4	#
5	5	# Tested with:
6		# * Ubuntu ~~8.10 (Intrepid Ibe~~x)
	6	# * Ubuntu 10.04 (Lucid Lynx)
7	7	#
8	8	# [ May as well work with other ubuntu flavors or debian.
…	…
40	40	gnuplot \
41	41	gv \
42		libmotif3 \
	42	libmotif4 \
43	43	xfig \
44	44	transfig \
…	…
127	127	echo "to /etc/apt/sources.list, e.g. using" ;\
128	128	echo "" ;\
129		echo "sudo ~~bash -c 'echo $SOURCE >> /etc/apt/sources.list~~'" ;\
130		echo "sudo apt~~itude~~ update" ;\
	129	echo "sudo apt-add-repository '$SOURCE'" ;\
	130	echo "sudo apt-get update" ;\
131	131	echo "???" ;\
132	132	)

branches/e4fix/SL/AW_NAME/needs_libs

r6865	r8274
2	2
3	3	SERVERCNTRL/SERVERCNTRL.a
4		~~WINDOW/libWINDOW~~.so
	4	AWT/libAWT.so

branches/e4fix/SL/HELIX/BI_basepos.cxx

r7423	r8274
15	15
16	16	static bool is_Gap(char c) { return c == '-' \|\| c == '.'; }
17		~~static CharPredicate pred_is_gap(is_Gap);~~
18	17
19	18	// ---------------------
…	…
21	20
22	21	void BasePosition::initialize(const char *seq, int size) {
	22	static CharPredicate pred_is_gap(is_Gap);
23	23	initialize(seq, size, pred_is_gap);
24	24	}

branches/e4fix/SL/LOCATION/Location.h

r8250	r8274
25	25	#endif
26	26
27		using std::vector; // @@@ do not use using decls in header w/o namespace
28		using std::string;
29		using std::map;
	27	typedef std::map<std::string, std::string> stringMap;
30	28
31		typedef map<string, string> stringMap;
32
33		typedef vector<int> intVector;
34		typedef vector<char> charVector;
35		typedef vector<bool> boolVector;
	29	typedef std::vector<int> intVector;
	30	typedef std::vector<char> charVector;
	31	typedef std::vector<bool> boolVector;
36	32
37	33	class GEN_position;
…	…
53	49	virtual void save(GEN_position *into, bool complementary) const = 0;
54	50	virtual LocationJoinType getJoinType() const = 0;
55		virtual st~~ring as_string() const~~ = 0;
	51	virtual std::string as_string() const = 0;
56	52
57	53	GEN_position *create_GEN_position() const;
…	…
60	56	typedef SmartPtr<Location> LocationPtr;
61	57
62		LocationPtr parseLocation(const string& source);
	58	LocationPtr parseLocation(const std::string& source);
63	59	LocationPtr to_Location(const GEN_position *gp);
64	60

branches/e4fix/SL/Makefile

r8041	r8274
17	17	HELIX/HELIX.dummy \
18	18	ITEMS/ITEMS.dummy \
	19	LOCATION/LOCATION.dummy \
19	20	MATRIX/MATRIX.dummy \
20	21	NDS/NDS.dummy \

branches/e4fix/SL/SEQIO/seq_export.cxx

r8103	r8274
522	522
523	523	static int export_depth = 0;
524		~~static int export_depth_max = 0;~~
525	524	export_depth++;
526	525
…	…
575	574	else {
576	575	XML_Document *xml = 0;
577
578		~~export_depth_max = export_depth;~~
579	576
580	577	int allCount = 0;

branches/e4fix/SL/TREEDISP/TreeCallbacks.cxx

r7811	r8274
558	558	GB_transaction gb_dummy(ntw->gb_main);
559	559	AWT_TREE(ntw)->check_update(ntw->gb_main);
560		AWT_TREE(ntw)->set_tree_type(type);
	560	AWT_TREE(ntw)->set_tree_type(type, ntw);
561	561	ntw->zoom_reset_and_refresh();
562	562	}
…	…
818	818	}
819	819
	820	void NT_reinit_treetype(AW_window , AWT_canvas ntw, AW_CL ) {
	821	AWT_graphic_tree gt = dynamic_cast<AWT_graphic_tree>(ntw->tree_disp);
	822	td_assert(gt);
	823	gt->set_tree_type(gt->tree_sort, ntw);
	824	AWT_resize_cb(ntw->aww, ntw, 0);
	825	}
	826
820	827	void NT_remove_species_in_tree_from_hash(AP_tree tree, GB_HASH hash) {
821	828	if (!tree) return;

branches/e4fix/SL/TREEDISP/TreeCallbacks.hxx

r7133	r8274
50	50	void NT_reload_tree_event P_((AW_root awr, AWT_canvas ntw, AW_CL expose));
51	51	void NT_recompute_cb P_((AW_window , AWT_canvas ntw, AW_CL cl2));
	52	void NT_reinit_treetype P_((AW_window , AWT_canvas ntw, AW_CL dummy_1x));
52	53	void NT_remove_species_in_tree_from_hash P_((AP_tree tree, GB_HASH hash));
53	54

branches/e4fix/SL/TREEDISP/TreeDisplay.cxx

r7916	r8274
1630	1630	}
1631	1631
1632		void AWT_graphic_tree::set_tree_type(AP_tree_sort type) {
	1632	void AWT_graphic_tree::set_tree_type(AP_tree_sort type, AWT_canvas *ntw) {
1633	1633	if (sort_is_list_style(type)) {
1634	1634	if (tree_sort == type) { // we are already in wanted view
…	…
1640	1640	}
1641	1641	tree_sort = type;
1642
1643		exports.set_standard_default_padding();
	1642	apply_zoom_settings_for_treetype(ntw); // sets default padding
1644	1643
1645	1644	exports.dont_fit_x = 0;
…	…
1681	1680	root_filter = AW_SCREEN\|AW_CLICK\|AW_PRINTER_EXT;
1682	1681
1683		set_tree_type(AP_TREE_NORMAL);
	1682	set_tree_type(AP_TREE_NORMAL, NULL);
1684	1683	tree_root_display = 0;
1685	1684	tree_proto = 0;
…	…
2563	2562	}
2564	2563
	2564	void AWT_graphic_tree::apply_zoom_settings_for_treetype(AWT_canvas *ntw) {
	2565	exports.set_standard_default_padding();
	2566
	2567	if (ntw) {
	2568	bool zoom_fit_text = false;
	2569	int left_padding = 0;
	2570	int right_padding = 0;
	2571
	2572	switch (tree_sort) {
	2573	case AP_TREE_RADIAL:
	2574	zoom_fit_text = aw_root->awar(AWAR_DTREE_RADIAL_ZOOM_TEXT)->read_int();
	2575	left_padding = aw_root->awar(AWAR_DTREE_RADIAL_XPAD)->read_int();
	2576	right_padding = left_padding;
	2577	break;
	2578
	2579	case AP_TREE_NORMAL:
	2580	case AP_TREE_IRS:
	2581	zoom_fit_text = aw_root->awar(AWAR_DTREE_DENDRO_ZOOM_TEXT)->read_int();
	2582	left_padding = STANDARD_PADDING;
	2583	right_padding = aw_root->awar(AWAR_DTREE_DENDRO_XPAD)->read_int();
	2584	break;
	2585
	2586	default :
	2587	break;
	2588	}
	2589
	2590	exports.set_default_padding(STANDARD_PADDING, STANDARD_PADDING, left_padding, right_padding);
	2591
	2592	ntw->set_consider_text_for_zoom_reset(zoom_fit_text);
	2593	}
	2594	}
	2595
2565	2596	void AWT_graphic_tree::show(AW_device *device) {
2566	2597	if (tree_static && tree_static->get_gb_tree()) {
…	…
2656	2687	aw_root->awar_float(AWAR_DTREE_CIRCLE_MAX_SIZE, 1.5, def) ->set_minmax(0.01, 200);
2657	2688	aw_root->awar_int(AWAR_DTREE_GREY_LEVEL, 20, def) ->set_minmax(0, 100);
	2689
	2690	aw_root->awar_int(AWAR_DTREE_RADIAL_ZOOM_TEXT, 0, def);
	2691	aw_root->awar_int(AWAR_DTREE_RADIAL_XPAD, 150, def);
	2692	aw_root->awar_int(AWAR_DTREE_DENDRO_ZOOM_TEXT, 0, def);
	2693	aw_root->awar_int(AWAR_DTREE_DENDRO_XPAD, 300, def);
2658	2694
2659	2695	aw_root->awar_int(AWAR_TREE_REFRESH, 0, def);
…	…
2892	2928	// #define TEST_AUTO_UPDATE // dont test, instead update expected results
2893	2929
2894		agt.set_tree_type(type);
	2930	agt.set_tree_type(type, NULL);
2895	2931
2896	2932	#if defined(TEST_AUTO_UPDATE)

branches/e4fix/SL/TREEDISP/TreeDisplay.hxx

r7916	r8274
31	31	#define AWAR_DTREE_GREY_LEVEL "awt/dtree/greylevel"
32	32
	33	#define AWAR_DTREE_RADIAL_ZOOM_TEXT "awt/dtree/radial/zoomtext"
	34	#define AWAR_DTREE_RADIAL_XPAD "awt/dtree/radial/xpadding"
	35
	36	#define AWAR_DTREE_DENDRO_ZOOM_TEXT "awt/dtree/dendro/zoomtext"
	37	#define AWAR_DTREE_DENDRO_XPAD "awt/dtree/dendro/xpadding"
	38
33	39	void awt_create_dtree_awars(AW_root *aw_root, AW_default def);
34	40
…	…
133	139
134	140	AD_map_viewer_cb map_viewer_cb;
135
	141
136	142	void scale_text_koordinaten(AW_device *device, int gc, double& x, double& y, double orientation, int flag);
137	143
…	…
164	170
165	171	virtual void read_tree_settings();
	172	void apply_zoom_settings_for_treetype(AWT_canvas *ntw);
166	173
167	174	protected:
…	…
228	235	int check_update(GBDATA *gb_main); // reload tree if needed
229	236	void update(GBDATA *gb_main);
230		void set_tree_type(AP_tree_sort type);
	237	void set_tree_type(AP_tree_sort type, AWT_canvas *ntw);
231	238
232	239	double get_irs_tree_ruler_scale_factor() const { return irs_tree_ruler_scale_factor; }
233	240	void get_zombies_and_duplicates(int& zomb, int& dups) const { zomb = zombies; dups = duplicates; }
234
	241
235	242	#if defined(UNIT_TESTS)
236	243	friend class fake_AWT_graphic_tree;

branches/e4fix/SOURCE_TOOLS/Makefile

r8171	r8274
	1	.SUFFIXES: .o .cxx
1	2
2	3	all:
3	4	@echo "use make clean"
4	5
	6	# --------------------------------------------------------------------------------
	7
	8	OBJECTS=arb_main_cpp.o arb_main_c.o
	9
	10	arb_main_cpp.o: arb_main.cxx Makefile
	11	$(CPP) $(cflags) -c $< -o $@ $(CPPINCLUDES) $(POST_COMPILE)
	12
	13	arb_main_c.o: arb_main.c arb_main.cxx Makefile
	14	$(ACC) $(cflags) -c $< -o $@ $(CPPINCLUDES) $(POST_COMPILE)
	15
	16	mainwrapper: $(OBJECTS)
	17
	18	# --------------------------------------------------------------------------------
	19
5	20	clean:
6		rm -f stamp.* ~~valgrind2grep.lst postcompile.sav~~
	21	rm -f stamp.* valgrind2grep.lst postcompile.sav $(OBJECTS)
7	22
8	23	valgrind_update:

branches/e4fix/SOURCE_TOOLS/dep.4dummy

r8041	r8274
1		~~ALIV3/ALIV3.dummy: SL/HELIX/HELIX.dummy~~
2	1	ARBDB/libARBDB.dummy: CORE/CORE.dummy
3	2	ARB_GDE/ARB_GDE.dummy: SL/AW_NAME/AW_NAME.dummy SL/GUI_ALIVIEW/GUI_ALIVIEW.dummy
…	…
8	7	CONVERTALN/CONVERTALN.dummy: SL/FILE_BUFFER/FILE_BUFFER.dummy
9	8	DBSERVER/DBSERVER.dummy: SERVERCNTRL/SERVERCNTRL.dummy
10		DIST/DIST.dummy: CONSENSUS_TREE/CONSENSUS_TREE.dummy SERVERCNTRL/SERVERCNTRL.dummy SL/ARB_TREE/ARB_TREE.dummy SL/GUI_ALIVIEW/GUI_ALIVIEW.dummy SL/MATRIX/MATRIX.dummy SL/NEIGHBOURJOIN/NEIGHBOURJOIN.dummy
11		EDIT4/EDIT4.dummy: ARB_GDE/ARB_GDE.dummy RNA3D/RNA3D.dummy SECEDIT/SECEDIT.dummy SL/AW_HELIX/AW_HELIX.dummy SL/FAST_ALIGNER/FAST_ALIGNER.dummy SL/~~ITEMS/ITEMS.dummy SL/~~TRANSLATE/TRANSLATE.dummy STAT/STAT.dummy
12		GENOM/GENOM.dummy: SL/DB_UI/DB_UI.dummy SL/NDS/NDS.dummy SL/TRANSLATE/TRANSLATE.dummy
	9	DIST/DIST.dummy: CONSENSUS_TREE/CONSENSUS_TREE.dummy SERVERCNTRL/SERVERCNTRL.dummy SL/ARB_TREE/ARB_TREE.dummy SL/GUI_ALIVIEW/GUI_ALIVIEW.dummy SL/MATRIX/MATRIX.dummy SL/NDS/NDS.dummy SL/NEIGHBOURJOIN/NEIGHBOURJOIN.dummy
	10	EDIT4/EDIT4.dummy: ARB_GDE/ARB_GDE.dummy RNA3D/RNA3D.dummy SECEDIT/SECEDIT.dummy SL/AW_HELIX/AW_HELIX.dummy SL/FAST_ALIGNER/FAST_ALIGNER.dummy SL/TRANSLATE/TRANSLATE.dummy STAT/STAT.dummy
	11	GENOM/GENOM.dummy: SL/DB_UI/DB_UI.dummy SL/LOCATION/LOCATION.dummy SL/NDS/NDS.dummy SL/TRANSLATE/TRANSLATE.dummy
13	12	GENOM_IMPORT/GENOM_IMPORT.dummy: GENOM/GENOM.dummy SL/FILE_BUFFER/FILE_BUFFER.dummy SL/REGEXPR/REGEXPR.dummy
14	13	GL/glAW/libglAW.dummy: WINDOW/WINDOW.dummy
…	…
34	33	SL/ARB_TREE/ARB_TREE.dummy: SL/SEQUENCE/SEQUENCE.dummy
35	34	SL/AW_HELIX/AW_HELIX.dummy: SL/HELIX/HELIX.dummy WINDOW/WINDOW.dummy
36		SL/AW_NAME/AW_NAME.dummy: ~~SERVERCNTRL/SERVERCNTRL.dummy WINDOW/WINDOW~~.dummy
	35	SL/AW_NAME/AW_NAME.dummy: AWT/AWT.dummy SERVERCNTRL/SERVERCNTRL.dummy
37	36	SL/DB_QUERY/DB_QUERY.dummy: SL/ITEMS/ITEMS.dummy
38	37	SL/DB_SCANNER/DB_SCANNER.dummy: SL/AW_NAME/AW_NAME.dummy SL/ITEMS/ITEMS.dummy
…	…
44	43	SL/HELIX/HELIX.dummy: ARBDB/ARBDB.dummy
45	44	SL/ITEMS/ITEMS.dummy: AWT/AWT.dummy
	45	SL/LOCATION/LOCATION.dummy: ARBDB/ARBDB.dummy
46	46	SL/MATRIX/MATRIX.dummy: WINDOW/WINDOW.dummy
47	47	SL/NDS/NDS.dummy: SL/ITEMS/ITEMS.dummy
…	…
57	57	SL/TREE_READ/TREE_READ.dummy: ARBDB/ARBDB.dummy
58	58	SL/TREE_WRITE/TREE_WRITE.dummy: XML/XML.dummy
59		STAT/STAT.dummy: SL/AP_TREE/AP_TREE.dummy SL/GUI_ALIVIEW/GUI_ALIVIEW.dummy
	59	STAT/STAT.dummy: SL/AP_TREE/AP_TREE.dummy SL/GUI_ALIVIEW/GUI_ALIVIEW.dummy SL/ITEMS/ITEMS.dummy
60	60	TOOLS/arb_probe.dummy: SERVERCNTRL/SERVERCNTRL.dummy
61	61	TOOLS/arb_test.dummy: ARBDB/ARBDB.dummy

branches/e4fix/SOURCE_TOOLS/dep.alltargets

r8041	r8274
1		~~ALIV3/ALIV3.a~~
2	1	ARBDB/libARBDB.so
3	2	ARB_GDE/ARB_GDE.a
…	…
44	43	SL/HELIX/HELIX.a
45	44	SL/ITEMS/ITEMS.a
	45	SL/LOCATION/LOCATION.a
46	46	SL/MATRIX/MATRIX.a
47	47	SL/NDS/NDS.a
…	…
63	63	WINDOW/libWINDOW.so
64	64	XML/XML.a
65		~~aliv3~~
66	65	arb_convert_aln
67	66	arb_db_server

branches/e4fix/SOURCE_TOOLS/dep.libtargets

r8041	r8274
1		~~ALIV3/ALIV3.a~~
2	1	ARBDB/libARBDB.so
3	2	ARB_GDE/ARB_GDE.a
…	…
44	43	SL/HELIX/HELIX.a
45	44	SL/ITEMS/ITEMS.a
	45	SL/LOCATION/LOCATION.a
46	46	SL/MATRIX/MATRIX.a
47	47	SL/NDS/NDS.a

branches/e4fix/SOURCE_TOOLS/export2sub

r7669	r8274
5	5
6	6	export ARBHOME
	7
	8	export use_ARB_main
	9	export use_ARB_main_C
7	10
8	11	export DEBUG

branches/e4fix/SOURCE_TOOLS/generate_all_links.sh

r8171	r8274
274	274	symlink_file ../SL/ITEMS/items.h INCLUDE/items.h &&
275	275	symlink_file ../SL/ITEMS/item_sel_list.h INCLUDE/item_sel_list.h &&
	276	symlink_file ../SL/LOCATION/Location.h INCLUDE/Location.h &&
276	277	symlink_file ../SL/MATRIX/AP_matrix.hxx INCLUDE/AP_matrix.hxx &&
277	278	symlink_file ../SL/NDS/nds.h INCLUDE/nds.h &&

branches/e4fix/SOURCE_TOOLS/needed_libs.pl

r7819	r8274
682	682	}
683	683	}
	684
	685	sub sortLibsByDependency(\@) {
	686	# sort libs for linker CL (fullfilling libs behind requesting libs)
	687	my ($libs_r) = @_;
	688	my @order = ();
	689	my %added = map { $_ => 0; } @$libs_r;
	690
	691	while (scalar(@order) < scalar(@$libs_r)) {
	692	my $didAdd = 0;
	693	foreach my $lib (@$libs_r) {
	694	if ($added{$lib}==0) { # not added yet
	695	my $all_dep_r = $all_dependencies_of{$lib};
	696	my $missing = 0;
	697	CHECK: foreach my $dep (keys %$all_dep_r) {
	698	my $was_added = $added{$dep};
	699	if (defined $was_added) {
	700	if ($was_added==0) { $missing = 1; last CHECK; }
	701	}
	702	}
	703	if ($missing==0) {
	704	push @order, $lib;
	705	$added{$lib} = 1;
	706	$didAdd = 1;
	707	}
	708	}
	709	}
	710	if ($didAdd==0) {
	711	die "internal error: did not add any lib in last loop (undetected nested dependency?)";
	712	}
	713	}
	714	@$libs_r = reverse @order;
	715	}
	716
684	717	sub pushStaticLibsTo($\@\@) {
685	718	my ($pathPrefix,$depends_r,$out_r) = @_;
686		~~foreach my $dep (@$depends_r) {~~
687		~~if (is_static_lib($dep)) {~~
688		~~push @$out_r, prefix($pathPrefix,$dep~~);
689		}
690		}
691		}
	719	my @libs = ();
	720	foreach my $dep (@$depends_r) { if (is_static_lib($dep)) { push @libs, $dep; } }
	721	sortLibsByDependency(@libs);
	722	foreach (@libs) { push @$out_r, prefix($pathPrefix,$_); }
	723	}
	724
692	725	sub pushDynamicLibsTo(\@\@) {
693	726	my ($depends_r,$out_r) = @_;
694		foreach my $dep (@$depends_r) {
695		if (is_dynamic_lib($dep)) {
696		push @$out_r, '-l'.dynamic_name($dep);
697		}
698		elsif (is_extra_param($dep)) {
699		push @$out_r, $dep;
700		}
701		}
	727	my @dep = ();
	728	foreach my $dep (@$depends_r) { if (is_dynamic_lib($dep)) { push @dep, $dep; } }
	729	sortLibsByDependency(@dep);
	730	foreach (@dep) { push @$out_r, '-l'.dynamic_name($_); }
	731	foreach my $dep (@$depends_r) { if (is_extra_param($dep)) { push @$out_r, $dep; } }
702	732	}
703	733
…	…
872	902	if ($printDirs==1) { pushDirsTo($pathPrefix,@track,@out); }
873	903	if ($printFiles==1) { pushFilesTo($pathPrefix,@track,@out); }
874		if ($printDynamic==1) { pushDynamicLibsTo(@track,@out); }
875		if ($printStatic==1) { pushStaticLibsTo($pathPrefix,@track,@out); }
	904
	905	{
	906	my @libs = ();
	907	if ($printStatic==1) { pushStaticLibsTo($pathPrefix,@track,@libs); }
	908	if ($printDynamic==1) { pushDynamicLibsTo(@track,@libs); }
	909
	910	foreach (@libs) { push @out, $_; }
	911	}
876	912
877	913	if (scalar(@out)>0) { print join(' ',@out)."\n"; }

branches/e4fix/SOURCE_TOOLS/tabBrake.pl

r8171	r8274
67	67	'GDE/PHYML',
68	68	'GDE/RAxML',
69		~~'GDE/MOLPHY',~~
70	69	'GDE/SUPPORT',
71	70	'GDE/PHYLIP',

branches/e4fix/STAT/ST_ml.cxx

r7811	r8274
801	801
802	802	const char *source_sequence = 0;
803		~~int source_sequence_len = 0;~~
804
805	803	GBDATA *gb_data = seq->get_bound_species_data();
806		if (gb_data) {
807		source_sequence_len = GB_read_string_count(gb_data);
808		source_sequence = GB_read_char_pntr(gb_data);
809		}
	804	if (gb_data) source_sequence = GB_read_char_pntr(gb_data);
810	805
811	806	// create color string in 'outs':

branches/e4fix/STAT/needs_libs

r6448	r8274
2	2
3	3	SL/AP_TREE/AP_TREE.a
	4	SL/ITEMS/ITEMS.a
4	5	SL/GUI_ALIVIEW/GUI_ALIVIEW.a

branches/e4fix/TEMPLATES/arb_str.h

r7811	r8274
51	51	inline void ARB_strlower(char *s) { for (int i = 0; s[i]; ++i) s[i] = tolower(s[i]); } // strlwr
52	52
	53	// ----------------------------------------
	54	// define the following inlines only if we have string
	55	#ifdef _GLIBCXX_STRING
	56
	57	inline bool beginsWith(const std::string& str, const std::string& start) {
	58	return str.find(start) == 0;
	59	}
	60
	61	inline bool endsWith(const std::string& str, const std::string& postfix) {
	62	size_t slen = str.length();
	63	size_t plen = postfix.length();
	64
	65	if (plen>slen) { return false; }
	66	return str.substr(slen-plen) == postfix;
	67	}
	68
	69	#else
	70
	71	#define beginsWith include_string_b4_arb_str_4_beginsWith
	72	#define endsWith include_string_b4_arb_str_4_endsWith
	73
	74	#endif
53	75
54	76	#else

branches/e4fix/TEMPLATES/arbtools.h

r7623	r8274
66	66	};
67	67
	68	#define DEFINE_NAMED_ITERATORS(type,name) \
	69	typedef type::iterator name##Iter; \
	70	typedef type::const_iterator name##CIter; \
	71	typedef type::reverse_iterator name##RIter; \
	72	typedef type::const_reverse_iterator name##CRIter
	73
	74	#define DEFINE_ITERATORS(type) DEFINE_NAMED_ITERATORS(type,type)
68	75
69	76	#else

branches/e4fix/TEMPLATES/dupstr.h

r7423	r8274
49	49	}
50	50
51		inline char nulldup(const char str) {
52		return ~~str ? strdup(s~~tr) : NULL;
	51	inline char nulldup(const char maybeStr) {
	52	return maybeStr ? strdup(maybeStr) : NULL;
53	53	}
54		inline void freedup(char & strvar, const char ~~no_heapcopy~~) {
55		freeset(strvar, nulldup(~~no_heapcopy~~));
	54	inline void freedup(char & strvar, const char maybeStr) {
	55	freeset(strvar, nulldup(maybeStr));
56	56	}
57	57	inline void reassign(char & dstvar, char & srcvar) {

branches/e4fix/TOOLS/Makefile

r8103	r8274
43	43
44	44	$(ARBHOME)/bin/arb_probe: arb_probe.o $(LIBS_ARB_PROBE)
45		$(LINK_EXECUTABLE) $@ $< $(LIBS_ARB_PROBE) $(LIB_ARBDB) $(EXECLIBS)
	45	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $< $(LIBS_ARB_PROBE) $(LIB_ARBDB) $(EXECLIBS)
46	46
47	47	$(ARBHOME)/bin/arb_read_tree: arb_read_tree.o $(LIBS_ARB_READ_TREE)
…	…
51	51	$(LINK_EXECUTABLE) $@ $< $(LIBS_ARB_EXPORT_TREE) $(LIB_ARBDB) $(EXECLIBS)
52	52
	53	$(ARBHOME)/bin/arb_a2ps: arb_a2ps.o
	54	$(LINK_EXECUTABLE) $@ $(use_ARB_main_C) $< $(LIB_ARBDB) $(EXECLIBS)
	55	# $(LINK_EXECUTABLE) $@ $< $(LIB_ARBDB) $(EXECLIBS)
	56
53	57	$(ARBHOME)/bin/%: %.o
54		$(LINK_EXECUTABLE) $@ $< $(LIB_ARBDB) $(EXECLIBS)
	58	$(LINK_EXECUTABLE) $@ $(use_ARB_main) $< $(LIB_ARBDB) $(EXECLIBS)
55	59
56	60	clean:

branches/e4fix/TOOLS/arb_2_ascii.cxx

r8100	r8274
12	12	#include <arb_handlers.h>
13	13
14		int ~~main(int argc, char **argv~~) {
	14	int ARB_main(int argc, const char *argv[]) {
15	15	GB_ERROR error = 0;
16	16
…	…
34	34	}
35	35	else {
36		char *in = argv[1];
37		char *out = NULL;
	36	const char *in = argv[1];
	37	const char *out = NULL;
38	38
39	39	const char *readflags = "rw";

branches/e4fix/TOOLS/arb_2_bin.cxx

r8037	r8274
12	12	#include <arbdbt.h>
13	13
14		int main(int argc, char **argv)
15		{
	14	int ARB_main(int argc, const char *argv[]) {
16	15	GB_ERROR error = 0;
17	16
…	…
22	21	"\n"
23	22	"Purpose: Converts a database to binary format\n"
24		"Syntax: arb_2_bin [~~-m] [-r] [-c][tree_xxx~~] database [newdatabase]\n"
	23	"Syntax: arb_2_bin [Options] database [newdatabase]\n"
25	24	"Options: -m create map file too\n"
26	25	" -r try to repair destroyed database\n"
…	…
35	34	}
36	35	else {
37		char rtype[256];
38		char wtype[256];
39		int ci = 1;
40		int ~~nidx~~ = 0;
41		int test = 0;
42		c~~har~~ *opt_tree = 0;
	36	char rtype[256];
	37	char wtype[256];
	38	int ci = 1;
	39	int nidx = 0;
	40
	41	const char *opt_tree = 0;
43	42
44	43	{
…	…
57	56	if (!strncmp(argv[ci], "-c", 2)) { opt_tree = argv[ci]+2; ci++; }
58	57	if (!strncmp(argv[ci], "-i", 2)) { nidx = atoi(argv[ci]+2); ci++; }
59		~~if (!strncmp(argv[ci], "-t", 2)) { test = 1; ci++; }~~
60	58	}
61	59	}
62	60
63		char *in = argv[ci++];
64		char *out = ci >= argc ? in : argv[ci++];
	61	const char *in = argv[ci++];
	62	const char *out = ci >= argc ? in : argv[ci++];
65	63
66	64	printf("Reading database...\n");

branches/e4fix/TOOLS/arb_a2ps.c

r7811	r8274
1743	1743	* Main routine for a2ps.
1744	1744	*/
1745		int
1746		main(argc, argv)
1747		int argc;
1748		char *argv[];
1749		{
1750		int narg;
1751		char *arg;
1752		int total;
	1745	int ARB_main(int argc, const char *cargv[]) {
	1746	char argv = (char)cargv;
	1747	int narg;
	1748	char *arg;
	1749	int total;
1753	1750	#if LPR_PRINT
1754		int fd[2];
1755		const char *lpr_args[10];
	1751	int fd[2];
	1752	const char *lpr_args[10];
1756	1753	#endif
1757	1754

branches/e4fix/TOOLS/arb_dnarates.cxx

r7916	r8274
1916	1916	inline bool wantSTDIN(const char *iname) { return is_char(iname, '-'); }
1917	1917
1918		int ~~main(int argc,~~ char *argv[]) {
	1918	int ARB_main(int argc, const char *argv[]) {
1919	1919	// Maximum Likelihood Site Rate
1920	1920	const char *dbname = ":";

branches/e4fix/TOOLS/arb_export_rates.cxx

r8037	r8274
28	28	#define MIO 1000000 // factor to scale rate-values to integers (for RAxML)
29	29
30		int ~~main(int argc, char **argv~~) {
	30	int ARB_main(int argc, const char *argv[]) {
31	31	argc--; argv++;
32	32

branches/e4fix/TOOLS/arb_gene_probe.cxx

r7212	r8274
476	476	}
477	477
478		int main(int argc, char* argv[]) {
	478	int ARB_main(int argc, const char *argv[]) {
479	479
480	480	printf("\n"

branches/e4fix/TOOLS/arb_message.cxx

r7190	r8274
12	12	#include <arbdbt.h>
13	13
14		int ~~main(int argc, char **argv~~) {
	14	int ARB_main(int argc, const char *argv[]) {
15	15	if (argc == 1) {
16	16	fprintf(stderr, "Usage: arb_message \"the message\"\n");

branches/e4fix/TOOLS/arb_notify.cxx

r8036	r8274
12	12	#include <arbdbt.h>
13	13
14		int main(int argc, char **argv)
15		{
	14	int ARB_main(int argc, const char *argv[]) {
16	15	if (argc == 1) {
17	16	fprintf(stderr, "Usage: arb_notify ID \"message\"\n");

branches/e4fix/TOOLS/arb_perf_test.cxx

r8037	r8274
136	136	}
137	137
138		int ~~main(int argc, char **argv~~)
	138	int ARB_main(int argc, const char *argv[])
139	139	{
140	140	GB_ERROR error = 0;
…	…
147	147	}
148	148	else {
149		char *in = argv[1];
	149	const char *in = argv[1];
150	150	gb_main = GBT_open(in, "rw");
151	151

branches/e4fix/TOOLS/arb_primer.cxx

r7811	r8274
300	300	}
301	301
302		int ~~main(int argc, char **argv~~) {
	302	int ARB_main(int argc, const char *argv[]) {
303	303	const char *path = NULL;
304	304

branches/e4fix/TOOLS/arb_probe.cxx

r8100	r8274
424	424	}
425	425
426		int ~~main(int argc, const char ** argv~~) {
	426	int ARB_main(int argc, const char *argv[]) {
427	427	bool ok = parseCommandLine(argc, argv);
428	428	if (ok) {

branches/e4fix/TOOLS/arb_read_tree.cxx

r7314	r8274
251	251
252	252	if (!error) {
253		// write tree comment:
254		const char *datestring;
255		{
256		time_t date;
257		if (time(&date) == -1) datestring = "<Error calculating time>";
258		else datestring = ctime(&date);
259		}
260
	253	// write tree comment
261	254	const char *comments[] = {
262	255	param.comment,

branches/e4fix/TOOLS/arb_replace.cxx

r8103	r8274
13	13	#include <arbdb.h>
14	14
15		int ~~main(int argc, char **argv~~) {
	15	int ARB_main(int argc, const char *argv[]) {
16	16	char *data;
17	17	char *ndata;
18	18	FILE *out;
19	19	int arg;
20		c~~har~~ *eval;
	20	const char *eval;
21	21	const char *fname;
22	22	int linemode = false;
…	…
68	68	if (data) {
69	69	if (patchmode) {
70		unsigned long size = GB_size_of_file(fname);
71		char *right = strchr(eval, '=');
72		int patched = false;
	70	unsigned long size = GB_size_of_file(fname);
	71	char *evaldup = strdup(eval);
	72	char *right = strchr(evaldup, '=');
	73	int patched = false;
73	74	if (!right) {
74	75	fprintf(stderr, "'=' not found in replace string\n");
75	76	return -1;
76	77	}
77		if (strlen(right) > strlen(eval)) {
	78	if (strlen(right) > strlen(evaldup)) {
78	79	fprintf(stderr, "You cannot replace a shorter string by a longer one!!!\n");
79	80	return -1;
…	…
82	83	*(right++) = 0;
83	84	unsigned long i;
84		int leftsize = strlen(eval);
	85	int leftsize = strlen(evaldup);
85	86	size -= leftsize;
86	87	for (i=0; i<size; i++) {
87		if (!strncmp(data+i, eval, leftsize)) {
	88	if (!strncmp(data+i, evaldup, leftsize)) {
88	89	strcpy(data+i, right);
89	90	patched = true;

branches/e4fix/TOOLS/arb_test.cxx

r8103	r8274
14	14	#include <unistd.h>
15	15
16		int main(int, char **) {
	16	int ARB_main(int , const char *[]) {
17	17	fputs("don't call us\n", stderr);
18	18	return EXIT_SUCCESS;

branches/e4fix/TREEGEN/sim.c

r7811	r8274
3	3	#include <stdlib.h>
4	4
5		int main(int argc, str argv[])
6		{
	5	int ARB_main(int argc, const char *argv[]) {
7	6	RNS origin;
8	7

branches/e4fix/UNIT_TESTER/sym2testcode.pl

r8176	r8274
276	276	my $MAIN = '';
277	277	my $have_main = defined $exported{'main'};
278		if ($have_main==0) {
279		$MAIN .= 'int main(void) {'."\n";
280		# $MAIN .= 'extern int jkahdfakshdu; jkahdfakshdu=1;'; # cause unittest compile error
281		# $MAIN .= 'int x=0; x=0;'; # cause unittest crash
282		$MAIN .= ' '.$UNIT_TESTER."\n";
283		$MAIN .= ' return EXIT_SUCCESS;'."\n";
284		$MAIN .= '}'."\n";
285		}
286		else {
287		$MAIN .= 'static '.$UNIT_TESTER."\n";
288		}
	278	if ($have_main==1) {
	279	$MAIN .= "#error tested code uses main() - not possible. use ARB_main instead and link normal executable with arb_main.o\n";
	280	}
	281	$MAIN .= 'int main(void) {'."\n";
	282	$MAIN .= ' '.$UNIT_TESTER."\n";
	283	$MAIN .= ' return EXIT_SUCCESS;'."\n";
	284	$MAIN .= '}'."\n";
289	285
290	286	print OUT $HEAD."\n";
…	…
315	311
316	312	parse($nm_output);
317		fail_if_no_tests_defined($libname);
	313	fail_if_no_tests_defined($libname); # comment out to disableErrorOnUnitsWithoutTests
318	314
319	315	filter($restrict);

branches/e4fix/UNIT_TESTER/test_unit.h

r8226	r8274
1166	1166
1167	1167
1168		#define TEST_ASSERT_NORESULT__ERROREXPORTED(create_result) TEST_ASSERT_NORESULT__ERROREXPORTED_CHECKERROR(create_result,~~NULL,~~NULL)
	1168	#define TEST_ASSERT_NORESULT__ERROREXPORTED(create_result) TEST_ASSERT_NORESULT__ERROREXPORTED_CHECKERROR(create_result,(void)NULL,(void)NULL)
1169	1169
1170	1170
…	…
1226	1226	#define TEST_ASSERT_EQUAL__BROKEN(e1,t2) TEST_EXPECT__BROKEN(that(e1).equals(t2))
1227	1227
1228		#define TEST_ASSERT_NULL(n) TEST_ASSERT_EQUAL(n, NULL)
1229		#define TEST_ASSERT_NULL__BROKEN(n) TEST_ASSERT_EQUAL__BROKEN(n, NULL)
	1228	#define TEST_ASSERT_NULL(n) TEST_ASSERT_EQUAL(n, (typeof(n))NULL)
	1229	#define TEST_ASSERT_NULL__BROKEN(n) TEST_ASSERT_EQUAL__BROKEN(n, (typeof(n))NULL)
1230	1230
1231	1231	#define TEST_ASSERT_SIMILAR(e1,t2,epsilon) TEST_EXPECT(that(e1).is(epsilon_similar(epsilon), t2))

branches/e4fix/WETC/WETC_main.cxx

r8036	r8274
17	17
18	18
19		int ~~main(int argc, char **argv~~) {
	19	int ARB_main(int argc, const char *argv[]) {
20	20	GB_ERROR error = NULL;
21	21

branches/e4fix/WINDOW/AW_button.cxx

r7811	r8274
934	934	AW_cb_struct *cbs;
935	935	VarUpdateInfo *vui;
936		char *~~String;~~
	936	char *str;
937	937	int x_correcting_for_label = 0;
938	938
…	…
940	940
941	941	AW_awar *vs = root->awar(var_name);
942		~~String~~ = root->awar(var_name)->read_as_string();
	942	str = root->awar(var_name)->read_as_string();
943	943
944	944	int width_of_input_label, height_of_input_label;
…	…
985	985	XmNwidth, (int)width_of_input,
986	986	XmNrows, 1,
987		XmNvalue, ~~String~~,
	987	XmNvalue, str,
988	988	XmNfontList, p_global->fontlist,
989	989	XmNbackground, _at->background_color,
…	…
994	994	}
995	995
996		free(~~String~~);
	996	free(str);
997	997
998	998	// user-own callback
…	…
1055	1055
1056	1056	void AW_window::create_text_field(const char *var_name, int columns, int rows) {
1057		Widget scrolledWindowText;
1058		Widget scrolledText;
1059		Widget ~~tmp_label~~ = 0;
1060		AW_cb_struct *cbs;
	1057	Widget scrolledWindowText;
	1058	Widget scrolledText;
	1059	Widget tmp_label = 0;
	1060	AW_cb_struct *cbs;
1061	1061	VarUpdateInfo *vui;
1062		char *String = NULL;
1063		short ~~width_of_last_widget~~ = 0;
1064		short ~~height_of_last_widget~~ = 0;
1065		int ~~width_of_text~~ = 0;
1066		int ~~height_of_text~~ = 0;
1067		int x_correcting_for_label = 0;
	1062	char *str = NULL;
	1063	short width_of_last_widget = 0;
	1064	short height_of_last_widget = 0;
	1065	int width_of_text = 0;
	1066	int height_of_text = 0;
	1067	int x_correcting_for_label = 0;
1068	1068
1069	1069	AW_awar *vs = root->awar(var_name);
1070		~~String~~ = root->awar(var_name)->read_string();
	1070	str = root->awar(var_name)->read_string();
1071	1071
1072	1072	int width_of_text_label, height_of_text_label;
…	…
1131	1131	scrolledWindowText,
1132	1132	XmNeditMode, XmMULTI_LINE_EDIT,
1133		XmNvalue, ~~String~~,
	1133	XmNvalue, str,
1134	1134	XmNscrollLeftSide, false,
1135	1135	XmNwidth, (int)width_of_text,
…	…
1138	1138	XmNbackground, _at->background_color,
1139	1139	NULL);
1140		free(~~String~~);
	1140	free(str);
1141	1141
1142	1142	if (!_at->to_position_exists) {

branches/e4fix/WINDOW/AW_preset.cxx

r7811	r8274
513	513	return GBT_write_int(gbd, AW_COLOR_GROUP_ENTRY, color_group);
514	514	}
	515
	516	struct gc_props {
	517	bool hidden;
	518	bool select_font;
	519	bool select_color;
	520
	521	bool fixed_fonts_only;
	522	bool append_same_line;
	523
	524	gc_props()
	525	: hidden(false),
	526	select_font(true),
	527	select_color(true),
	528	fixed_fonts_only(false),
	529	append_same_line(false)
	530	{}
	531
	532	private:
	533	bool parse_char(char c) {
	534	switch (c) {
	535	case '#': fixed_fonts_only = true; break;
	536	case '+': append_same_line = true; break;
	537
	538	case '=': select_color = false; break;
	539	case '-': {
	540	if (select_font) select_font = false;
	541	else hidden = true; // two '-' means 'hidden'
	542	break;
	543	}
	544
	545	default : return false;
	546	}
	547	return true;
	548	}
	549
	550	void correct() {
	551	if (!select_font && !select_color) hidden = true;
	552	if (append_same_line && select_font) append_same_line = false;
	553	}
	554	public:
	555
	556	int parse_decl(const char *decl) {
	557	// returns number of (interpreted) prefix characters
	558	int offset = 0;
	559	while (decl[offset]) {
	560	if (!parse_char(decl[offset])) break;
	561	offset++;
	562	}
	563	correct();
	564	return offset;
	565	}
	566	};
515	567
516	568	AW_gc_manager AW_manage_GC(AW_window *aww,
…	…
574	626	gcmgrfirst = gcmgrlast = new aw_gc_manager(mcbs->window_awar_name, 0);
575	627
576		const char *~~old~~_font_base_name = "default";
	628	const char *last_font_base_name = "default";
577	629
578	630	char background[50];
…	…
596	648
597	649	while (id) {
598		bool flag_fixed_fonts_only = false;
599		bool flag_no_color_selector = false;
600		bool flag_append_in_same_line = false;
601		bool flag_no_fonts = false;
602
	650	gc_props gcp;
603	651	AW_MGC_awar_cb_struct *acbs = 0;
604	652	{
…	…
658	706	}
659	707
660		int offset = 0;
661		while (1) {
662		switch (id_copy[offset]) {
663		case '#': flag_fixed_fonts_only = true; offset++; continue;
664		case '=': flag_no_color_selector = true; offset++; continue;
665		case '+': flag_append_in_same_line = true; offset++; continue;
666		case '-': flag_no_fonts = true; offset++; continue;
667		default: break;
668		}
669		break;
670		}
671
	708	gcp.parse_decl(id_copy);
672	709	freenull(id_copy);
673	710	}
674	711
675		if (flag_fixed_fonts_only) def_font = AW_DEFAULT_FIXED_FONT;
676		else def_font = AW_DEFAULT_NORMAL_FONT;
	712	def_font = gcp.fixed_fonts_only ? AW_DEFAULT_FIXED_FONT : AW_DEFAULT_NORMAL_FONT;
677	713
678	714	if ((area != AW_GCM_DATA_AREA) \|\| !first) {
…	…
696	732	aw_gc_color_changed_cb(aw_root, acbs, -1);
697	733
698		~~if (flag_no_fonts) acbs->fontbasename = old~~_font_base_name;
699		~~else old_font_base_name = acbs->fontbasename = acbs->color~~basename;
	734	acbs->fontbasename = gcp.select_font ? acbs->colorbasename : last_font_base_name;
	735	last_font_base_name = acbs->fontbasename;
700	736
701	737	{
…	…
705	741	AW_awar *font_size_awar = aw_root->awar_int(awar_name, DEF_FONTSIZE, aw_def);
706	742
707		if (~~!flag_no_fonts~~) {
	743	if (gcp.select_font) {
708	744	font_awar->add_callback(aw_font_changed_cb, (AW_CL)acbs);
709	745	gcmgr2->set_font_change_parameter(acbs);
…	…
771	807	bool has_color_groups = false;
772	808	const char *window_awar_name = gcmgr->get_field();
773		~~bool first = true;~~
774	809
775	810	for (gcmgr = gcmgr->get_next(); gcmgr; gcmgr = gcmgr->get_next()) {
776	811	const char *id = gcmgr->get_field();
777
778		bool flag_fixed_fonts_only = false;
779		bool flag_no_color_selector = false;
780		bool flag_append_in_same_line = false;
781		bool flag_no_fonts = false;
782		bool flag_hide_this_gc = false;
783
784		while (1) {
785		switch (id[0]) {
786		case '#': flag_fixed_fonts_only = true; id++; continue;
787		case '=': flag_no_color_selector = true; id++; continue;
788		case '+': flag_append_in_same_line = true; id++; continue;
789		case '-': {
790		if (flag_no_fonts) flag_hide_this_gc = true; // if gc definition contains -- the gc is completely hidden
791		else flag_no_fonts = true;
792		id++;
793		continue;
794		}
795		default: break;
796		}
797		break;
798		}
	812	gc_props gcp;
	813
	814	id += gcp.parse_decl(id);
799	815
800	816	char *fontbasename = GBS_string_2_key(id);
…	…
812	828	}
813	829
814		if (!~~flag_hide_this_gc~~) {
	830	if (!gcp.hidden) {
815	831	sprintf(awar_name, AWP_COLORNAME_TEMPLATE, window_awar_name, fontbasename);
816	832	aws->label_length(15);
…	…
826	842	}
827	843
828		if (~~!flag_no_color_select~~or) {
	844	if (gcp.select_color) {
829	845	aws->button_length(5);
830	846	AW_preset_create_color_chooser(aws, awar_name, id);
…	…
832	848	aws->create_input_field(awar_name, 7);
833	849
834		if (~~!flag_no_fonts~~) {
	850	if (gcp.select_font) {
835	851	sprintf(awar_name, AWP_FONTNAME_TEMPLATE, window_awar_name, fontbasename);
836	852
…	…
844	860	font_string = AW_font_2_ascii((AW_font) font_nr);
845	861	if (!font_string) break;
846		if (~~flag_~~fixed_fonts_only && AW_font_2_xfig((AW_font) font_nr) >= 0) continue;
	862	if (gcp.fixed_fonts_only && AW_font_2_xfig((AW_font) font_nr) >= 0) continue;
847	863	aws->insert_option(font_string, 0, (int) font_nr);
848	864	}
…	…
861	877	aw_init_font_sizes(aw_root, acs, true); // does update_option_menu
862	878	}
863		if (!flag_append_in_same_line) aws->at_newline();
864		}
865		first = false;
	879	if (!gcp.append_same_line) aws->at_newline();
	880	}
866	881	free(fontbasename);
867	882	}

branches/e4fix/WINDOW/AW_window.cxx

r8194	r8274
2574	2574	}
2575	2575
2576		int AW_window::create_mode(const char pixmap, const char helpText, AW_active Mask, void (f)(AW_window, AW_CL, AW_CL), AW_CL cd1, AW_CL cd2) {
2577		aw_assert(legal_mask(Mask));
	2576	int AW_window::create_mode(const char pixmap, const char helpText, AW_active mask, void (f)(AW_window, AW_CL, AW_CL), AW_CL cd1, AW_CL cd2) {
	2577	aw_assert(legal_mask(mask));
2578	2578	Widget button;
2579	2579
…	…
2610	2610	}
2611	2611
2612		root->make_sensitive(button, Mask);
	2612	root->make_sensitive(button, mask);
2613	2613	p_w->number_of_modes++;
2614	2614
…	…
2822	2822	// --------------------------------------------------------------------------------
2823	2823
2824		void AW_window::create_menu(AW_label name, const char *mnemonic, AW_active Mask) {
2825		aw_assert(legal_mask(Mask));
	2824	void AW_window::create_menu(AW_label name, const char *mnemonic, AW_active mask) {
	2825	aw_assert(legal_mask(mask));
2826	2826	p_w->menu_deep = 0;
2827	2827	#ifdef DEBUG
…	…
2831	2831	dumpCloseAllSubMenus();
2832	2832	#endif // DUMP_MENU_LIST
2833		insert_sub_menu(name, mnemonic, Mask);
	2833	insert_sub_menu(name, mnemonic, mask);
2834	2834	}
2835	2835
…	…
2846	2846	}
2847	2847
2848		void AW_window::insert_sub_menu(AW_label name, const char *mnemonic, AW_active Mask) {
2849		aw_assert(legal_mask(Mask));
	2848	void AW_window::insert_sub_menu(AW_label name, const char *mnemonic, AW_active mask) {
	2849	aw_assert(legal_mask(mask));
2850	2850	Widget shell, Label;
2851	2851
…	…
2900	2900	if (p_w->menu_deep < AW_MAX_MENU_DEEP-1) p_w->menu_deep++;
2901	2901
2902		root->make_sensitive(Label, Mask);
	2902	root->make_sensitive(Label, mask);
2903	2903	}
2904	2904
…	…
2915	2915
2916	2916	void AW_window::insert_menu_topic(const char *topic_id, AW_label name,
2917		const char mnemonic, const char helpText, AW_active Mask,
	2917	const char mnemonic, const char helpText, AW_active mask,
2918	2918	void (f)(AW_window, AW_CL, AW_CL), AW_CL cd1, AW_CL cd2)
2919	2919	{
2920		aw_assert(legal_mask(Mask));
	2920	aw_assert(legal_mask(mask));
2921	2921	Widget button;
2922	2922
…	…
2956	2956	cbs->id = strdup(topic_id);
2957	2957	root->define_remote_command(cbs);
2958		root->make_sensitive(button, Mask);
2959		}
2960
2961		void AW_window::insert_help_topic(AW_label name, const char mnemonic, const char helpText, AW_active Mask,
	2958	root->make_sensitive(button, mask);
	2959	}
	2960
	2961	void AW_window::insert_help_topic(AW_label name, const char mnemonic, const char helpText, AW_active mask,
2962	2962	void (f)(AW_window, AW_CL, AW_CL), AW_CL cd1, AW_CL cd2)
2963	2963	{
2964		aw_assert(legal_mask(Mask));
	2964	aw_assert(legal_mask(mask));
2965	2965	Widget button;
2966	2966
…	…
2974	2974	(XtPointer) new AW_cb_struct(this, f, cd1, cd2, helpText));
2975	2975
2976		root->make_sensitive(button, Mask);
	2976	root->make_sensitive(button, mask);
2977	2977	}
2978	2978

branches/e4fix/arb_LICENSE.txt

r7895	r8274
236	236	which is provided in 'lib/GPL.txt'.
237	237
238		~~molphy~~
239
240		~~MOLPHY: A Computer Program Package for Molecular Phylogenetics~~
241
242		~~Readme~~
243		~~This is the MOLPHY (ProtML) distribution, version 2.3.~~
244		~~Copyright (c) 1992-1996, Jun Adachi & Masami Hasegawa.~~
245		~~All rights reserved.~~
246
247		~~MOLPHY is a program package for MOLecular PHYlogenetics.~~
248
249		~~ProtML is a main program in MOLPHY for inferring evolutionary trees from~~
250		~~PROTein (amino acid) sequences by using the Maximum Likelihood method.~~
251
252		~~Programs (C language)~~
253		~~ProtML: Maximum Likelihood Inference of Protein Phylogeny~~
254		~~NucML: Maximum Likelihood Inference of Nucleic Acid Phylogeny~~
255		~~ProtST: Basic Statistics of Protein Sequences~~
256		~~NucST: Basic Statistics of Nucleic Acid Sequences~~
257		~~NJdist: Neighbor Joining Phylogeny from Distance Matrix~~
258		~~Utilities (Perl)~~
259		~~mollist: get identifiers list molrev: reverse DNA sequences~~
260		~~molcat: concatenate sequences molcut: get partial sequences~~
261		~~molmerge: merge sequences nuc2ptn: DNA -> Amino acid~~
262		~~rminsdel: remove INS/DEL sites molcodon: get specified codon sites~~
263		~~molinfo: get varied sites mol2mol: MOLPHY format beautifer~~
264		~~inl2mol: Interleaved -> MOLPHY mol2inl: MOLPHY -> Interleaved~~
265		~~mol2phy: MOLPHY -> Sequential phy2mol: Sequential -> MOLPHY~~
266		~~must2mol: MUST -> MOLPHY etc.~~
267
268		~~MOLPHY is a free software, and you can use and redistribute it.~~
269		~~The programs are written in a standard subset of C with UNIX-like OS.~~
270		~~The utilities are written in the "Perl" (Ver.4.036) with UNIX-like OS.~~
271		~~MOLPHY has been tested on SUN4's (cc & gcc with SUN-OS 4.1.3) and~~
272		~~HP9000/700 (cc, c89 & gcc with HP-UX 9.05).~~
273		~~However, MOLPHY has NOT been tested on VAX, IBM-PC, and Macintosh.~~
274
275		~~NETWORK DISTRIBUTION ONLY: The latest version of MOLPHY is always available~~
276		~~by anonymous ftp in ftp.ism.ac.jp: /pub/ISMLIB/MOLPHY/.~~
277
278	238	readseq
279	239

branches/e4fix/arb_README.txt

r6211	r8274
9	9	ARB is currently developed on Linux PCs only.
10	10
11		Compiling ARB using the gcc compiler (~~versions 2.95.3, 3.x and~~ 4.x series)
	11	Compiling ARB using the gcc compiler (4.x series)
12	12	as well works on Mac OSX and Sun OS - but we do not publish or support
13	13	these versions.
…	…
39	39	'arb.64.*.tgz' // 64 bit versions
40	40
41		~~'arb..SuSE.tgz // SuSE version~~
42		~~'arb..Ubuntu.tgz // Ubuntu version (recommended)~~
43
44	41	'arb.*.OPENGL.tgz' // OPENGL version (contains RNA3D, a 3D-molecule-viewer)
45	42
…	…
48	45	choose a 64-bit-version, if your system is 64-bit.
49	46
50		Normally one of the Ubuntu versions should work for you, only
51		use one of the SuSE versions, if the Ubuntu version has problems
52		(e.g. does not display group names in ARB_EDIT4).
	47	You need only ONE of the available 'arb.*.tgz'!
53	48
54	49
…	…
66	61	'arb_install.sh' // install script
67	62	'arb_README.txt' // this file
68		'arb.*.tgz' // ARB binaries
	63	'arb.*.tgz' // your chosen ARB version
	64
69	65
70	66	are located and type

branches/e4fix/arb_UBUNTU.txt

r7489	r8274
1	1
2		ARB requirements on Ubuntu ~~8.10~~
3		-------------------------------
	2	ARB requirements on Ubuntu 10.04
	3	--------------------------------
4	4
5	5	[Note:]

Context Navigation

Legend: