AISC_COM/AISC/Makefile

+THIS=AISC/Makefile
+MAKETHIS=$(MAKE) -f $(THIS)
+#MAKETHIS=$(MAKE) -d -f $(THIS)
+SED:=$(ARBHOME)/SH/arb_sed
+READLINK:=$(ARBHOME)/SH/arb_readlink
+
+.SUFFIXES: .o .c .h .aisc
+
+#where to find the creator files
+AISC=../AISC/aisc
+AISC_MKPT = ../AISC_MKPTPS/aisc_mkpt
+
+RUN_AISC:=$(AISC)
+# valgrinding like this breaks the build process (due to wrong exitcode)
+#RUN_AISC:=arb_valgrind -c 15 $(AISC)
+#RUN_AISC:=arb_valgrind -c 15 -l $(AISC)
+#RUN_AISC:=arb_valgrind -c 15 -l -r $(AISC)
+
+GEN_INCLUDES = GENH/aisc.h GENH/aisc_com.h
+INCLUDE_INCLUDES = aisc_include.header
+
+SERVER_OBJECTS = O/server.o O/struct_man.o O/aisc_extern.o
+
+GEN_SERVER_PROTO_OBJECTS = GENC/aisc_server.o
+GEN_SERVER_OTHER_OBJECTS = GENC/aisc_global.o
+GEN_SERVER_OBJECTS = $(GEN_SERVER_PROTO_OBJECTS) $(GEN_SERVER_OTHER_OBJECTS)
+
+GEN_SERVER_PROTO_SOURCES = $(GEN_SERVER_PROTO_OBJECTS:.o=.c)
+GEN_SERVER_SOURCES = $(GEN_SERVER_OBJECTS:.o=.c)
+
+GEN_SERVER_INCLUDES = C/aisc_server.h C/common.h
+GEN_SERVER_PROTO = GENH/aisc_server_proto.h
+GEN_SERVER_EXTERN_PROTO = GENH/aisc_server_extern.h
+
+SERVER_INCLUDES = $(GEN_INCLUDES) $(GEN_SERVER_INCLUDES) $(GEN_SERVER_PROTO) $(GEN_SERVER_EXTERN_PROTO)
+
+CLIENT_OBJECTS = O/client.o 
+CLIENT_INCLUDES = $(GEN_INCLUDES) C/client_privat.h C/client.h C/common.h
+
+COMMON_OBJECTS = O/common.o
+COMMON_INCLUDES = C/common.h
+
+AISC_EXTERNALS = C/aisc_extern.c $(PRIVATE_SERVER_OBJECTS:.o=.c)
+GLOBALS_AISC = GENH/global.aisc
+
+AISC_DEPENDS = AISC/*.pa $(MAIN_SOURCE) $(AISC) $(DUMPDIR) $(GLOBALS_AISC)
+
+IMPORT_PROTO = GENH/import_proto.h
+
+SERVER = server.a
+CLIENT = client.a
+COMMON = common.a
+
+AISC_SERVER_EXTERN = GENH/aisc_server_extern.aisc
+
+DUMPDIR=DUMP
+
+LINK_TO_OTHER_ARB=~/ARB.aisc_regression_test_vs# create this as symlink to other ARB checkout to activate regression test 
+FAIL_ON_CHANGE=1# 0=continue on change, 1=fail on change
+
+# ----------------------------------------
+
+COMPARE_WITH_OTHER_ARB:=$(shell $(READLINK) $(LINK_TO_OTHER_ARB))
+ifneq ($(COMPARE_WITH_OTHER_ARB),)
+THIS__COMDIR=$(shell pwd)
+COMDIRNAME=$(subst $(ARBHOME),,$(THIS__COMDIR))
+OTHER_COMDIR=$(subst //,/,$(COMPARE_WITH_OTHER_ARB)/$(COMDIRNAME))
+ifeq ($(FAIL_ON_CHANGE),0)
+REGR_FAILURE=(echo "$(THIS):57: Warning: regression on generated code (ignored)" || true)
+else
+REGR_FAILURE=(	echo "$(THIS):59: Error: regression on generated AISC code"; \
+		rm $(SERVER) $(CLIENT) $(COMMON); \
+		false) 
+endif
+endif
+
+# ----------------------------------------
+
+ifeq ($(AUTODEPENDS),1)
+all:
+	+test -f .depends || $(MAKETHIS) "AUTODEPENDS=0" .depends
+	+$(MAKETHIS) "AUTODEPENDS=2" all
+else
+all: directories
+	+$(MAKETHIS) realall
+
+endif
+
+realall: $(CLIENT) $(SERVER) $(COMMON) Makefile $(THIS)
+ifeq ($(COMPARE_WITH_OTHER_ARB),)
+	@echo "AISC regression tests are disabled ($(LINK_TO_OTHER_ARB) not found from AISC_COM/$(THIS))"
+else
+ ifeq ($(THIS__COMDIR),$(OTHER_COMDIR))
+	@echo "$(THIS):63: Warning: Skipping AISC regression tests (test versus self always ok)"
+ else
+	@echo "Running AISC regression tests (versus $(COMPARE_WITH_OTHER_ARB))"
+#       compare generated code using ../../SOURCE_TOOLS/check_dirs_equal.sh
+	@( \
+		../SOURCE_TOOLS/check_dirs_equal.sh $(THIS__COMDIR)/GENC $(OTHER_COMDIR)/GENC '*.c' && \
+		../SOURCE_TOOLS/check_dirs_equal.sh $(THIS__COMDIR)/GENH $(OTHER_COMDIR)/GENH '*.h' && \
+		../SOURCE_TOOLS/check_dirs_equal.sh $(THIS__COMDIR)/DUMP $(OTHER_COMDIR)/DUMP '*.dump' && \
+		echo "No change in generated code" \
+	) || $(REGR_FAILURE)
+ endif
+endif
+
+pregenerate: $(GEN_SERVER_SOURCES) $(SERVER_INCLUDES) $(CLIENT_INCLUDES) $(AISC_EXTERNALS)
+
+directories:
+	@mkdir -p GENH GENC O DUMP
+
+GENH:	directories
+GENC:	directories
+O:	directories
+DUMP:	directories
+
+$(SERVER): $(SERVER_OBJECTS) $(GEN_SERVER_OBJECTS) $(PRIVATE_SERVER_OBJECTS)
+	$(LINK_STATIC_LIB) $@ $^
+
+$(CLIENT): $(CLIENT_OBJECTS) $(GEN_CLIENT_OBJECTS)
+	$(LINK_STATIC_LIB) $@ $^
+
+$(COMMON): $(COMMON_OBJECTS)
+	$(LINK_STATIC_LIB) $@ $^ 
+
+$(GEN_SERVER_OBJECTS) $(PRIVATE_SERVER_OBJECTS): $(SERVER_INCLUDES) $(GEN_SERVER_SOURCES) $(PRIVATE_SERVER_OBJECTS:.o=.c)
+	$(COMPILER) -c -o $@ $(@:.o=.c) -IGENH -I. -IC -DAISC_SAVE_$(AISC_SAVE) $(POST_COMPILE)
+
+O/%.o: C/%.c $(GEN_INCLUDES) $(CLIENT_INCLUDES) C/server.h
+	$(COMPILER) -c -o $@ $< -IGENH -I. -IC $(POST_COMPILE)
+
+$(CLIENT_OBJECTS): $(CLIENT_OBJECTS:O/%.o=C/%.c) $(GEN_INCLUDES) $(CLIENT_INCLUDES)
+	$(CLIENTCOMPILER) -c -o $@ C/$(@F:.o=.c) -IGENH -I. -IC $(POST_COMPILE)
+
+$(DUMPDIR): 
+	mkdir -p $(DUMPDIR)
+
+$(GLOBALS_AISC).tmp: 
+	@echo "AISC_SAVE $(AISC_SAVE);" > $@
+
+$(GLOBALS_AISC): $(GLOBALS_AISC).tmp
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff $(GLOBALS_AISC).tmp $(GLOBALS_AISC)
+
+GENH/%.h: AISC/%.pa $(AISC_DEPENDS) $(INCLUDE_INCLUDES) 
+	$(RUN_AISC) $< $(MAIN_SOURCE) $@
+
+GENC/%.c: AISC/%.pa $(AISC_DEPENDS) $(AISC_SERVER_EXTERN) $(GEN_SERVER_INCLUDES)
+	$(RUN_AISC) $< $(MAIN_SOURCE) $@ $(AISC_SERVER_EXTERN) $(IMPORT_PROTO) $(GLOBALS_AISC)
+
+$(IMPORT_PROTO): $(GEN_SERVER_PROTO_SOURCES)
+	echo $@
+
+$(AISC_SERVER_EXTERN): $(AISC_EXTERNALS) $(AISC_MKPT) $(THIS) 
+	rm -f $(AISC_SERVER_EXTERN)
+	$(AISC_MKPT) -a $(AISC_EXTERNALS) >$@
+
+$(GEN_SERVER_EXTERN_PROTO): $(AISC_EXTERNALS) $(AISC_MKPT) $(THIS)
+	rm -f $(GEN_SERVER_EXTERN_PROTO)
+	$(AISC_MKPT) -w $(subst GENH/,,$@) $(AISC_EXTERNALS) >$@
+
+$(GEN_SERVER_PROTO): $(GEN_SERVER_PROTO_SOURCES) $(AISC_MKPT) $(THIS)
+	rm -f $@
+	$(AISC_MKPT) -w $(subst GENH/,,$@) $(GEN_SERVER_PROTO_SOURCES) >$@
+
+clean:
+	@rm -f *.[ao] */*.[ao]
+	@rm -rf GENH GENC DUMP O
+	@rm -f .depends
+
+.depends:
+	$(MAKEDEPEND) $(MAKEDEPENDFLAGS) C/*.c GENC/*.c -I GENH -I C -f- -w1 2>/dev/null \
+		| grep -v ' /usr' \
+		| $(SED) -e 's/^C/O/ig' \
+		> .depends_new
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff .depends_new .depends
+
+ifeq ($(AUTODEPENDS),2)
+include .depends
+endif

AISC_COM/C/Makefile

+
+all:
+	echo "Available targets: proto"
+
+GENERATED_HEADERS= \
+	aisc_extern_privat.h \
+	client.h \
+	common.h \
+	server.h \
+	struct_man.h \
+
+AISC_MKPT_FLAGS=-P -G
+MKPT_DEP=../../AISC_MKPTPS/aisc_mkpt Makefile
+
+proto:
+	$(MAKE) $(GENERATED_HEADERS)
+
+clean:
+	rm $(GENERATED_HEADERS)
+
+aisc_extern_privat.h: aisc_extern.c $(MKPT_DEP)  
+	$(ARBHOME)/AISC_MKPTPS/aisc_mkpt $(AISC_MKPT_FLAGS) -w $@ $< >$@.tmp
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff $@.tmp $@
+
+client.h: client.c $(MKPT_DEP)
+	$(ARBHOME)/AISC_MKPTPS/aisc_mkpt $(AISC_MKPT_FLAGS) -w $@ $< >$@.tmp
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff $@.tmp $@
+
+common.h: common.c $(MKPT_DEP)
+	$(ARBHOME)/AISC_MKPTPS/aisc_mkpt $(AISC_MKPT_FLAGS) -w $@ $< >$@.tmp
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff $@.tmp $@
+
+struct_man.h: struct_man.c $(MKPT_DEP)
+	$(ARBHOME)/AISC_MKPTPS/aisc_mkpt $(AISC_MKPT_FLAGS) -w $@ $< >$@.tmp
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff $@.tmp $@
+
+server.h: server.c $(MKPT_DEP)
+	$(ARBHOME)/AISC_MKPTPS/aisc_mkpt $(AISC_MKPT_FLAGS) -w $@ $< >$@.tmp
+	$(ARBHOME)/SOURCE_TOOLS/mv_if_diff $@.tmp $@
+
+

AISC_COM/C/aisc_extern.c

+#include <stdio.h>
+#include <string.h>
+#include <aisc.h>
+#include <server.h>
+#include "aisc_extern_privat.h"
+
+extern int aisc_d_flags[];
+
+dll_public *create_dll_public() {
+    return 0;
+}
+
+int move_dll_header(const dll_header *sobj, dll_header *dobj) {
+    dobj->ident = strdup(sobj->ident);
+    return 0;
+}
+
+int get_COMMON_CNT(dll_header *THIS) {
+    int key = (int)(THIS->key) >> 16;
+    if (aisc_d_flags[key] == 0) return -1;
+    if (!((THIS->parent))) { return 0; }
+    return THIS->parent->cnt;
+}
+
+dllheader_ext *get_COMMON_PARENT(dll_header *THIS) {
+    int key = (int)(THIS->key) >> 16;
+    if (aisc_d_flags[key] == 0) return 0;
+    if (!THIS->parent) { return 0; }
+    return THIS->parent->parent;
+}
+
+dllheader_ext *get_COMMON_LAST(dll_header *THIS) {
+    int key = (int)(THIS->key) >> 16;
+    if (aisc_d_flags[key] == 0) return 0;
+    if (!THIS->parent) { return 0; }
+    return THIS->parent->last;
+}
+
+aisc_cstring aisc_get_keystring(int *obj) {
+    int i;
+    i = *obj>>16;
+    return aisc_get_object_names(i);
+}
+
+aisc_cstring aisc_get_keystring_dll_header(dll_header *x) {
+    return aisc_get_keystring((int*)x);
+}

AISC_COM/C/aisc_extern_privat.h

+/* This file is generated by aisc_mkpt.
+ * Any changes you make here will be overwritten later!
+ */
+
+#ifndef AISC_EXTERN_PRIVAT_H
+#define AISC_EXTERN_PRIVAT_H
+
+/* define ARB attributes: */
+#ifndef ATTRIBUTES_H
+# include <attributes.h>
+#endif
+
+
+/* aisc_extern.c */
+dll_public *create_dll_public(void);
+int move_dll_header(const dll_header *sobj, dll_header *dobj);
+int get_COMMON_CNT(dll_header *THIS);
+dllheader_ext *get_COMMON_PARENT(dll_header *THIS);
+dllheader_ext *get_COMMON_LAST(dll_header *THIS);
+aisc_cstring aisc_get_keystring(int *obj);
+aisc_cstring aisc_get_keystring_dll_header(dll_header *x);
+
+#else
+#error aisc_extern_privat.h included twice
+#endif /* AISC_EXTERN_PRIVAT_H */

AISC_COM/C/aisc_func_types.h

+// =============================================================== //
+//                                                                 //
+//   File      : aisc_func_types.h                                 //
+//   Purpose   :                                                   //
+//                                                                 //
+//   Coded by Ralf Westram (coder@reallysoft.de) in 2000           //
+//   Institute of Microbiology (Technical University Munich)       //
+//   http://www.arb-home.de/                                       //
+//                                                                 //
+// =============================================================== //
+
+#ifndef AISC_FUNC_TYPES_H
+#define AISC_FUNC_TYPES_H
+
+struct sigcontext;
+struct Hs_struct;
+
+#define aisc_talking_func_proto_void(func_name)     void func_name(long arg1, ...)
+#define aisc_talking_func_proto_long(func_name)     long func_name(long arg1, ...)
+#define aisc_talking_func_proto_longp(func_name)    long* func_name(long arg1, ...)
+#define aisc_talking_func_proto_double(func_name)   double func_name(long arg1, ...)
+
+typedef aisc_talking_func_proto_void((*aisc_destroy_callback));
+typedef aisc_talking_func_proto_long((*aisc_talking_func_long));
+typedef aisc_talking_func_proto_longp((*aisc_talking_func_longp));
+typedef aisc_talking_func_proto_double((*aisc_talking_func_double));
+
+#else
+#error aisc_func_types.h included twice
+#endif // AISC_FUNC_TYPES_H

AISC_COM/C/aisc_global.h

+// =============================================================== //
+//                                                                 //
+//   File      : aisc_global.h                                     //
+//   Purpose   :                                                   //
+//                                                                 //
+//   Coded by Ralf Westram (coder@reallysoft.de) in May 2007       //
+//   Institute of Microbiology (Technical University Munich)       //
+//   http://www.arb-home.de/                                       //
+//                                                                 //
+// =============================================================== //
+#ifndef AISC_GLOBAL_H
+#define AISC_GLOBAL_H
+
+#ifndef BYTESTRING_H
+#include <bytestring.h>
+#endif
+#ifndef ARBTOOLS_H
+#include <arbtools.h>
+#endif
+#ifndef ATTRIBUTES_H
+#include <attributes.h>
+#endif
+#ifndef ARB_ASSERT_H
+#include <arb_assert.h>
+#endif
+
+#define aisc_assert(cond) arb_assert(cond)
+
+// type mask
+#define AISC_TYPE_NONE   0x00000000
+#define AISC_TYPE_INT    0x01000000
+#define AISC_TYPE_DOUBLE 0x02000000
+#define AISC_TYPE_STRING 0x03000000
+#define AISC_TYPE_COMMON 0x04000000
+#define AISC_TYPE_BYTES  0x05000000
+
+#define AISC_VAR_TYPE_MASK 0xff000000
+#define AISC_OBJ_TYPE_MASK 0x00ff0000
+#define AISC_ATTR_MASK     0x0000ffff
+
+#define AISC_INDEX       0x1ff0000
+#define AISC_NO_ANSWER  -0x7fffffff
+
+#define AISC_COMMON      0
+
+union double_xfer { // workaround aliasing problems
+    double as_double;
+    int    as_int[2];
+};
+
+class AISC_Object : public Noncopyable {
+    int  type_id;
+    long remote_ptr; // this is a pointer to client-data in server-address-space (casted to long)
+
+    void *operator&() { return 0; } // forbid error-prone idiom (AISC_Object just was 'long' in the past). Instead use as_result_param()
+
+protected:
+
+    void set(int IF_ASSERTION_USED(remoteType), long remotePtr) { aisc_assert(remoteType == type_id); remote_ptr = remotePtr; }
+
+public:
+    AISC_Object(int type_) : type_id(type_), remote_ptr(0) {}
+
+    bool exists() const { return remote_ptr; }
+    long get() const { return remote_ptr; }
+    int type() const { return type_id; }
+
+    void clear() { remote_ptr = 0; }
+    void init(long remotePtr) { aisc_assert(!exists()); set(type_id, remotePtr); }
+
+    long *as_result_param() { return &remote_ptr; }
+
+};
+
+#else
+#error aisc_global.h included twice
+#endif // AISC_GLOBAL_H
+

AISC_COM/C/aisc_server.h

+// --------------------------------------------------------------------------------
+// start ../../AISC_COM/C/aisc_server.h
+//
+// [Note: This header isn't included directly, it's merged into generated code by AISC]
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <dupstr.h>
+#include <aisc.h>
+#include <aisc_com.h>
+
+#ifndef ATTRIBUTES_H
+#include <attributes.h>
+#endif
+#include <server.h>
+#include <aisc_server_proto.h>
+#include <aisc_server_extern.h>
+#include <import_proto.h>
+
+#include <struct_man.h>
+
+// end ../../AISC_COM/C/aisc_server.h
+// --------------------------------------------------------------------------------

AISC_COM/C/client.h

+/* This file is generated by aisc_mkpt.
+ * Any changes you make here will be overwritten later!
+ */
+
+#ifndef CLIENT_H
+#define CLIENT_H
+
+/* define ARB attributes: */
+#ifndef ATTRIBUTES_H
+# include <attributes.h>
+#endif
+
+
+/* client.c */
+
+#include <client_types.h>
+
+aisc_com *aisc_open(const char *path, AISC_Object& main_obj, long magic, GB_ERROR *error);
+int aisc_close(aisc_com *link, AISC_Object& object);
+int aisc_get(aisc_com *link, int o_type, const AISC_Object& object, ...) __ATTR__SENTINEL;
+long *aisc_debug_info(aisc_com *link, int o_type, const AISC_Object& object, int attribute);
+int aisc_put(aisc_com *link, int o_type, const AISC_Object& object, ...) __ATTR__SENTINEL;
+int aisc_nput(aisc_com *link, int o_type, const AISC_Object& object, ...) __ATTR__SENTINEL;
+int aisc_create(aisc_com *link, int father_type, const AISC_Object& father, int attribute, int object_type, AISC_Object& object, ...) __ATTR__SENTINEL;
+
+#else
+#error client.h included twice
+#endif /* CLIENT_H */

AISC_COM/C/client_privat.h

+// =============================================================== //
+//                                                                 //
+//   File      : client_privat.h                                   //
+//   Purpose   :                                                   //
+//                                                                 //
+//   Institute of Microbiology (Technical University Munich)       //
+//   http://www.arb-home.de/                                       //
+//                                                                 //
+// =============================================================== //
+
+#ifndef CLIENT_PRIVAT_H
+#define CLIENT_PRIVAT_H
+
+#ifndef AISC_GLOBAL_H
+#include "aisc_global.h"
+#endif
+
+
+#ifndef ARB_ASSERT_H
+#include <arb_assert.h>
+#endif
+#ifndef SIGHANDLER_H
+#include <SigHandler.h>
+#endif
+
+#define AISC_MAX_ATTR           4095
+#define MAX_AISC_SET_GET        16
+#define AISC_MAX_STRING_LEN     1024
+#define AISC_MESSAGE_BUFFER_LEN ((AISC_MAX_STRING_LEN/4+3)*(16+2))
+
+struct aisc_bytes_list {
+    char            *data;
+    int              size;
+    aisc_bytes_list *next;
+};
+
+struct aisc_com {
+    int         socket;
+    int         message_type;
+    char       *message;
+    int        *message_queue;
+    long        magic;
+    const char *error;
+
+    long             aisc_mes_buffer[AISC_MESSAGE_BUFFER_LEN];
+    aisc_bytes_list *aisc_client_bytes_first;
+    aisc_bytes_list *aisc_client_bytes_last;
+    SigHandler       old_sigpipe_handler;
+};
+
+#define AISC_MAGIC_NUMBER 0
+
+enum aisc_command_list {
+    AISC_GET         = AISC_MAGIC_NUMBER + 0,
+    AISC_SET         = AISC_MAGIC_NUMBER + 1,
+    AISC_NSET        = AISC_MAGIC_NUMBER + 2,
+    AISC_CREATE      = AISC_MAGIC_NUMBER + 3,
+    AISC_FIND        = AISC_MAGIC_NUMBER + 4,
+    AISC_COPY        = AISC_MAGIC_NUMBER + 5,
+    AISC_DELETE      = AISC_MAGIC_NUMBER + 6,
+    AISC_INIT        = AISC_MAGIC_NUMBER + 7,
+    AISC_DEBUG_INFO  = AISC_MAGIC_NUMBER + 8,
+    AISC_FORK_SERVER = AISC_MAGIC_NUMBER + 9
+};
+
+enum aisc_client_command_list {
+    AISC_CCOM_OK      = AISC_MAGIC_NUMBER + 0,
+    AISC_CCOM_ERROR   = AISC_MAGIC_NUMBER + 1,
+    AISC_CCOM_MESSAGE = AISC_MAGIC_NUMBER + 2
+};
+
+#else
+#error client_privat.h included twice
+#endif // CLIENT_PRIVAT_H

AISC_COM/C/client_types.h

+// ============================================================== //
+//                                                                //
+//   File      : client_types.h                                   //
+//   Purpose   : AISC types used by clients                       //
+//                                                                //
+//   Coded by Ralf Westram (coder@reallysoft.de) in August 2010   //
+//   Institute of Microbiology (Technical University Munich)      //
+//   http://www.arb-home.de/                                      //
+//                                                                //
+// ============================================================== //
+
+#ifndef CLIENT_TYPES_H
+#define CLIENT_TYPES_H
+
+#ifndef __cplusplus
+#error AISC clients no longer work in plain C
+#endif
+
+#ifndef AISC_GLOBAL_H
+#include <aisc_global.h>
+#endif
+#ifndef ARB_ASSERT_H
+#include <arb_assert.h>
+#endif
+
+#else
+#error client_types.h included twice
+#endif // CLIENT_TYPES_H

AISC_COM/C/common.c

+// ================================================================ //
+//                                                                  //
+//   File      : common.c                                           //
+//   Purpose   : Common code for server and client                  //
+//                                                                  //
+//   Institute of Microbiology (Technical University Munich)        //
+//   http://www.arb-home.de/                                        //
+//                                                                  //
+// ================================================================ //
+
+#include "common.h"
+
+#include <dupstr.h>
+#include <arb_cs.h>
+#include <arb_msg.h>
+#include <arb_assert.h>
+
+#include <netdb.h>
+#include <netinet/tcp.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+enum ClientOrServer { AISC_SERVER, AISC_CLIENT };
+
+inline const char *who(ClientOrServer cos) {
+    switch (cos) {
+        case AISC_SERVER: return "AISC_SERVER";
+        case AISC_CLIENT: return "AISC_CLIENT";
+    }
+    arb_assert(0);
+    return "<unknown>";
+}
+
+static GB_ERROR common_get_m_id(const char *path, char **m_name, int *id) {
+    GB_ERROR error = NULL;
+    if (!path) {
+        error = "missing hostname:socketid";
+    }
+    else {
+        if (strcmp(path, ":") == 0) {
+            path = getenv("SOCKET");
+            if (!path) {
+                error = "expected environment variable 'SOCKET' (needed to connect to ':')";
+            }
+        }
+
+        if (!error) {
+            const char *p = strchr(path, ':');
+            if (path[0] == '*' || path[0] == ':') {     // UNIX MODE
+                char buffer[128];
+                if (!p) {
+                    error = "missing ':' in *:socketid";
+                }
+                else {
+                    if (p[1] == '~') {
+                        sprintf(buffer, "%s%s", getenv("HOME"), p+2);
+                        *m_name = (char *)strdup(buffer);
+                    }
+                    else {
+                        *m_name = (char *)strdup(p+1);
+                    }
+                    *id = -1;
+                }
+            }
+            else {
+                if (!p) {
+                    error = "missing ':' in netname:socketid";
+                }
+                else {
+                    char *mn = (char *) calloc(sizeof(char), p - path + 1);
+                    strncpy(mn, path, p - path);
+
+                    /* @@@ falls hier in mn ein der Bereich von path bis p stehen soll, fehlt eine abschliesende 0 am String-Ende
+                       auf jeden Fall erzeugt der folgende strcmp einen (rui) */
+
+                    if (strcmp(mn, "localhost") == 0) freedup(mn, arb_gethostname());
+
+                    *m_name = mn;
+                    int i   = atoi(p + 1);
+                    if ((i < 1024) || (i > 32000)) {
+                        error = "socketnumber is not in range [1024..32000]";
+                    }
+                    else {
+                        *id = i;
+                    }
+                }
+            }
+        }
+    }
+    return error;
+}
+
+#define SOCKET_EXISTS_AND_CONNECT_WORKED ""
+
+static GB_ERROR common_open_socket(ClientOrServer cos, const char *path, int delay, int do_connect, int *psocket, char **unix_name) {
+    char     *mach_name = NULL;
+    int       socket_id;
+    GB_ERROR  error     = common_get_m_id(path, &mach_name, &socket_id);
+
+    if (!error) {
+        const char one = 1;
+        if (socket_id >= 0) {       // UNIX
+            sockaddr_in so_ad;
+            memset((char *)&so_ad, 0, sizeof(sockaddr_in));
+            *psocket = socket(PF_INET, SOCK_STREAM, 0);
+            if (*psocket <= 0) {
+                error = "failed to create socket"; // @@@ reason why
+            }
+            else {
+                struct hostent *he;
+                arb_gethostbyname(mach_name, he, error);
+                if (!error) {
+                    // simply take first address
+                    struct in_addr addr;
+                    addr.s_addr      = *(int *) (he->h_addr);
+                    so_ad.sin_addr   = addr;
+                    so_ad.sin_family = AF_INET;
+                    so_ad.sin_port   = htons(socket_id);    // @@@ = pb_socket
+                    if (do_connect) {
+                        if (connect(*psocket, (struct sockaddr*)&so_ad, 16)) {
+                            error = SOCKET_EXISTS_AND_CONNECT_WORKED;
+                        }
+                    }
+                    else {
+                        setsockopt(*psocket, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+                        if (bind(*psocket, (struct sockaddr*)&so_ad, 16)) {
+                            error = "Could not open socket on Server (1)";
+                        }
+                    }
+                    if (!error) {
+                        if (delay == TCP_NODELAY) {
+                            static int optval;
+                            optval = 1;
+                            setsockopt(*psocket, IPPROTO_TCP, TCP_NODELAY, (char *)&optval, 4);
+                        }
+                        *unix_name = 0;
+                    }
+                }
+            }
+        }
+        else {
+            struct sockaddr_un so_ad;
+            *psocket = socket(PF_UNIX, SOCK_STREAM, 0);
+            if (*psocket <= 0) {
+                error = "cannot create socket"; // @@@ reason why
+            }
+            else {
+                so_ad.sun_family = AF_UNIX;
+                strcpy(so_ad.sun_path, mach_name);
+                if (do_connect) {
+                    if (connect(*psocket, (struct sockaddr*)&so_ad, strlen(mach_name)+2)) {
+                        error = SOCKET_EXISTS_AND_CONNECT_WORKED;
+                    }
+                }
+                else {
+                    FILE *test = fopen(mach_name, "r");
+                    if (test) {
+                        struct stat stt;
+                        if (!stat(path, &stt)) {
+                            if (S_ISREG(stt.st_mode)) {
+                                fprintf(stderr, "%X\n", stt.st_mode);
+                                error = "Socket already exists as a file";
+                            }
+                        }
+                        fclose(test);
+                    }
+
+                    if (!error) {
+                        if (unlink(mach_name) != 0) {
+                            printf("Warning: old socket file '%s' failed to unlink\n", mach_name);
+                        }
+                        if (cos == AISC_SERVER) {
+                            setsockopt(*psocket, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+                        }
+                        if (bind(*psocket, (struct sockaddr*)&so_ad, strlen(mach_name)+2)) {
+                            error = "Could not open socket on Server (2)"; // @@@ reasons ?
+                        }
+                        if (!error && cos == AISC_SERVER) {
+                            if (chmod(mach_name, 0777)) {
+                                error = "Cannot change mode of socket"; // @@@ reasons!
+                            }
+                        }
+                    }
+                }
+
+                if (!error) reassign(*unix_name, mach_name);
+            }
+        }
+    }
+
+    free(mach_name);
+
+    if (error && *error) { // real error (see SOCKET_EXISTS_AND_CONNECT_WORKED)
+        error = GBS_global_string("%s-Error: %s", who(cos), error);
+    }
+    return error;
+}
+
+const char *aisc_client_open_socket(const char *path, int delay, int do_connect, int *psocket, char **unix_name) {
+    return common_open_socket(AISC_CLIENT, path, delay, do_connect, psocket, unix_name);
+}
+const char *aisc_server_open_socket(const char *path, int delay, int do_connect, int *psocket, char **unix_name) { // @@@ rename into aisc_server_open_socket
+    return common_open_socket(AISC_SERVER, path, delay, do_connect, psocket, unix_name);
+}
+

AISC_COM/C/common.h

+/* This file is generated by aisc_mkpt.
+ * Any changes you make here will be overwritten later!
+ */
+
+#ifndef COMMON_H
+#define COMMON_H
+
+/* define ARB attributes: */
+#ifndef ATTRIBUTES_H
+# include <attributes.h>
+#endif
+
+
+/* common.c */
+const char *aisc_client_open_socket(const char *path, int delay, int do_connect, int *psocket, char **unix_name);
+const char *aisc_server_open_socket(const char *path, int delay, int do_connect, int *psocket, char **unix_name);
+
+#else
+#error common.h included twice
+#endif /* COMMON_H */

AISC_COM/C/server.h

+/* This file is generated by aisc_mkpt.
+ * Any changes you make here will be overwritten later!
+ */
+
+#ifndef SERVER_H
+#define SERVER_H
+
+/* define ARB attributes: */
+#ifndef ATTRIBUTES_H
+# include <attributes.h>
+#endif
+
+
+/* server.c */
+
+#include <aisc_func_types.h>
+#ifndef _STDIO_H
+#include <stdio.h>
+#endif
+
+void aisc_server_errorf(const char *templat, ...) __ATTR__FORMAT(1);
+const char *aisc_get_object_names(long i);
+Hs_struct *open_aisc_server(const char *path, int timeout, int fork);
+int aisc_talking_get_index(int u, int o);
+long aisc_make_sets(long *obj);
+int aisc_broadcast(Hs_struct *hs, int message_type, const char *message);
+Hs_struct *aisc_accept_calls(Hs_struct *hs);
+void aisc_server_shutdown(Hs_struct*& hs);
+void aisc_server_shutdown_and_exit(Hs_struct *hs, int exitcode) __ATTR__NORETURN __ATTR__DEPRECATED_TODO("cause it hides a call to exit() inside a library");
+int aisc_add_destroy_callback(aisc_destroy_callback callback, long clientdata);
+void aisc_remove_destroy_callback(void);
+int aisc_server_save_token(FILE *fd, const char *buffer, int maxsize);
+int aisc_server_load_token(FILE *fd, char *buffer, int maxsize);
+
+#else
+#error server.h included twice
+#endif /* SERVER_H */

AISC_COM/C/struct_man.c

+// ==============================================================
+/*                                                                */
+//   File      : struct_man.c
+//   Purpose   :
+/*                                                                */
+//   Institute of Microbiology (Technical University Munich)
+//   http://www.arb-home.de/
+ /*                                                                */
+ // ==============================================================
+
+
+#include <aisc.h>
+#include <struct_man.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// AISC_MKPT_PROMOTE:struct aisc_hash_node;
+
+// ---------------------
+//      hash tables
+
+
+#define CORE
+#define HASH_SIZE 103123
+#define TRF_HASH_SIZE 103123
+
+struct aisc_hash_node {
+    char           *key;
+    long            data;
+    aisc_hash_node *next;
+};
+
+
+static aisc_hash_node **aisc_init_hash(int size) {
+    struct aisc_hash_node **tab;
+    tab = (aisc_hash_node **) calloc(sizeof(aisc_hash_node *), size);
+    tab[0] = (aisc_hash_node *) calloc(sizeof(aisc_hash_node), 1);
+    tab[0]->data = size;
+    tab[0]->key = (char *)strdup("len_of_hash_table_(c) oliver_strunk 1.3.93");
+    return tab;
+}
+
+static int aisc_hash(const char *key, int size) {
+    unsigned int i, len, x;
+    len = strlen(key);
+    x = 0;
+    for (i=0; i<len; i++) {
+        x = x<<2 ^ key[i];
+    }
+    x = x%size;
+    return x;
+}
+
+static void aisc_free_key(aisc_hash_node **table, char *key) {
+    if (table && table[0]) {
+        long size = table[0]->data;
+        long i    = aisc_hash(key, (int)size);
+
+        aisc_hash_node *hn, *hhn;
+        for (hn = hhn = table[i]; hn; hn = hn->next) {
+            if (strcmp(key, hn->key)) {
+                hhn = hn;
+                continue;
+            }
+            if (hn != hhn)
+                hhn->next = hn->next;
+            else {
+                table[i] = hhn->next;
+            }
+            free(hn->key);
+            free(hn);
+            break;
+        }
+    }
+}
+
+static void aisc_free_hash(aisc_hash_node **table) {
+    long end = table[0]->data;
+    for (long i=0; i<end; i++) {
+        aisc_hash_node *hn, *hnn;
+        for (hn = table[i]; hn; hn=hnn) {
+            hnn = hn->next;
+            free(hn->key);
+            free(hn);
+        }
+    }
+    free(table);
+}
+
+
+static void aisc_insert_hash(aisc_hash_node **table, char *key, long data) {
+    long            size = table[0]->data;
+    long            i    = aisc_hash(key, (int)size);
+
+    aisc_hash_node *hnl  = 0;
+    aisc_hash_node *hn;
+    for (hn=table[i]; hn; hn=hn->next) {
+        hnl = hn;
+        if (strcmp(key, hn->key) == 0) {
+            hn->data = data;
+            return;
+        }
+    }
+    hn = (aisc_hash_node *)calloc(sizeof(aisc_hash_node), 1);
+    hn->key = (char *)strdup(key);
+    hn->data = data;
+    if (hnl) {
+        hnl->next = hn;
+    }
+    else {
+        table[i] = hn;
+    }
+}
+
+long aisc_read_hash(aisc_hash_node **table, const char *key) {
+    if (table && table[0]) {
+        long size = table[0]->data;
+        long i = aisc_hash(key, (int)size);
+        for (aisc_hash_node *hn=table[i]; hn; hn=hn->next) {
+            if (strcmp(key, hn->key) == 0) return hn->data;
+        }
+    }
+    return 0;
+}
+
+// ----------------------
+//      link control
+
+const char *aisc_link(dllpublic_ext *father, dllheader_ext *object) {
+    if (!object) {
+        CORE;
+        return "Object is (NULL)";
+    }
+    if (object->mh.parent) {
+        CORE;
+        return "Object already linked";
+    }
+    if (!father) {
+        CORE;
+        return "Parent is (NULL)";
+    }
+    if (father->key != object->mh.key) {
+        CORE;
+        return "Parent key doesn't match Object key";
+    }
+    if (object->mh.ident) {
+        if (strlen(object->mh.ident) <= 0) {
+            CORE;
+            return "Too short ident";
+        }
+        if (father->hash) {
+            if (aisc_read_hash((aisc_hash_node **)father->hash, object->mh.ident)) {
+                CORE;
+                return "Object already in list";
+            }
+            else {
+                aisc_insert_hash((aisc_hash_node **)father->hash, object->mh.ident, (long)object);
+            }
+        }
+        else {
+            father->hash = (long)aisc_init_hash(HASH_SIZE);
+            aisc_insert_hash((aisc_hash_node **)father->hash, object->mh.ident, (long)object);
+        }
+    }
+    object->next = object->previous = NULL;
+    if (!father->first) {
+        father->cnt   = 1;
+        father->first = object;
+        father->last  = object;
+    }
+    else {
+        father->cnt++;
+        object->previous   = father->last;
+        father->last->next = object;
+        father->last       = object;
+    }
+    object->mh.parent = father;
+    return 0;
+}
+
+
+
+const char *aisc_unlink(dllheader_ext *object) {
+    dllpublic_ext *father = (dllpublic_ext *)object->mh.parent;
+
+    if (!father) {
+        CORE;
+        return "Object not linked";
+    }
+    if (father->hash) {
+        aisc_free_key((aisc_hash_node **)father->hash, object->mh.ident);
+    }
+    if (father->cnt <= 0) {
+        CORE;
+        return "Parent count is 0";
+    }
+    if (object->previous) {
+        if (object->previous->next != object) {
+            CORE;
+            return "Fatal Error: Object is a copy, not original";
+        }
+        object->previous->next = object->next;
+    }
+    else {
+        father->first = object->next;
+    }
+    if (object->next) {
+        object->next->previous = object->previous;
+    }
+    else {
+        father->last = object->previous;
+    }
+    object->mh.parent = NULL;
+    object->previous  = NULL;
+    object->next      = NULL;
+
+    father->cnt--;
+    if (!father->cnt) {
+        if (father->hash) {
+            aisc_free_hash((aisc_hash_node **)father->hash);
+            father->hash = 0;
+        }
+    }
+    return 0;
+}
+
+long aisc_find_lib(dllpublic_ext *parent, char *ident)
+{
+    if (!parent->hash) return 0;
+    if (!ident) return 0;
+    return aisc_read_hash((aisc_hash_node **)parent->hash, ident);
+}
+
+
+struct trf_dest_struct {
+    struct trf_dest_struct *next;
+    long                   *dest;
+};
+
+struct trf_struct {
+    struct trf_struct      *next;
+    long                    new_item;
+    long                    old;
+    struct trf_dest_struct *dests;
+};
+
+static int trf_hash(long p)
+{
+    return (p+(p>>8))&(TRF_HASH_SIZE-1);
+}
+
+static int trf_level = 0;
+static struct trf_struct **trf_sp = 0;
+
+void trf_create(long old, long new_item) {
+    long i;
+    struct trf_struct *ts;
+    struct trf_dest_struct *tds, *ntds;
+    if (!trf_sp) return;
+    i = trf_hash(old);
+    for (ts = trf_sp[i]; ts; ts = ts->next) {
+        if (ts->old == old) {
+            if (ts->new_item && (ts->new_item != new_item)) {
+                GBK_terminate("ERROR IN trf_create");
+            }
+            else {
+                ts->new_item = new_item;
+                for (tds = ts->dests; tds; tds = ntds) {
+                    *tds->dest = new_item;
+                    ntds = tds->next;
+                    free(tds);
+                }
+            }
+            return;
+        }
+    }
+    ts = (struct trf_struct *)calloc(sizeof(struct trf_struct), 1);
+    ts->next = trf_sp[i];
+    trf_sp[i] = ts;
+    ts->new_item = new_item;
+    ts->old = old;
+}
+
+void trf_link(long old, long *dest)
+{
+    long i;
+    struct trf_struct *ts, *fts;
+    struct trf_dest_struct *tds;
+    if (!trf_sp) return;
+    i = trf_hash(old);
+    fts = 0;
+    for (ts = trf_sp[i]; ts; ts = ts->next) {
+        if (ts->old == old)     { fts = ts; break; }
+    }
+    if (!fts) {
+        ts = (struct trf_struct *)calloc(sizeof(struct trf_struct), 1);
+        ts->next = trf_sp[i];
+        trf_sp[i] = ts;
+        ts->old = old;
+        fts = ts;
+    }
+    tds = (struct trf_dest_struct *)calloc(sizeof(struct trf_dest_struct), 1);
+    tds->next = fts->dests;
+    fts->dests = tds;
+    tds->dest = dest;
+}
+
+void trf_begin() {
+    if (trf_level==0) {
+        trf_sp = (struct trf_struct **)calloc(sizeof(struct trf_struct *), TRF_HASH_SIZE);
+    }
+    trf_level ++;
+}
+
+void trf_commit(int errors) {
+    // if errors == 1 then print errors and CORE
+    struct trf_dest_struct *tds, *ntds;
+    struct trf_struct *ts, *nts;
+    trf_level--;
+    if (!trf_level) {
+        for (int i = 0; i < TRF_HASH_SIZE; i++) {
+            for (ts = trf_sp[i]; ts; ts = nts) {
+                if (errors) {
+                    if (ts->dests) {
+                        GBK_terminate("ERROR IN trf_commit");
+                    }
+                }
+                else {
+                    for (tds = ts->dests; tds; tds = ntds) {
+                        ntds = tds->next;
+                        free(tds);
+                    }
+                }
+                nts = ts->next;
+                free(ts);
+            }
+        }
+        free(trf_sp);
+        trf_sp = 0;
+    }
+}
+

AISC_COM/C/struct_man.h

+/* This file is generated by aisc_mkpt.
+ * Any changes you make here will be overwritten later!
+ */
+
+#ifndef STRUCT_MAN_H
+#define STRUCT_MAN_H
+
+/* define ARB attributes: */
+#ifndef ATTRIBUTES_H
+# include <attributes.h>
+#endif
+
+
+/* struct_man.c */
+
+struct aisc_hash_node;
+
+long aisc_read_hash(aisc_hash_node **table, const char *key);
+const char *aisc_link(dllpublic_ext *father, dllheader_ext *object);
+const char *aisc_unlink(dllheader_ext *object);
+long aisc_find_lib(dllpublic_ext *parent, char *ident);
+void trf_create(long old, long new_item);
+void trf_link(long old, long *dest);
+void trf_begin(void);
+void trf_commit(int errors);
+
+#else
+#error struct_man.h included twice
+#endif /* STRUCT_MAN_H */

AISC_COM/C/trace.h

+// =============================================================== //
+//                                                                 //
+//   File      : trace.h                                           //
+//   Purpose   :                                                   //
+//                                                                 //
+//   Coded by Ralf Westram (coder@reallysoft.de) in May 2007       //
+//   Institute of Microbiology (Technical University Munich)       //
+//   http://www.arb-home.de/                                       //
+//                                                                 //
+// =============================================================== //
+#ifndef TRACE_H
+#define TRACE_H
+
+#if defined(DEBUG)
+// #define DUMP_COMMUNICATION
+#endif // DEBUG
+
+// --------------------------------------------------------------------------------
+
+#if defined(DUMP_COMMUNICATION)
+
+static void aisc_dump_hex(const char *title, const char *data, int datasize) {
+    const unsigned char *udata = (const unsigned char *)data;
+    int d;
+
+    fprintf(stderr, "%s", title);
+    for (d = 0; d<datasize; d++) {
+        fprintf(stderr, "%02X", udata[d]);
+    }
+    fprintf(stderr, "\n");
+}
+
+static void aisc_dump_int(const char *where, const char *varname, int var) {
+    fprintf(stderr, "AISC_DUMP: %s: int    %s=%i ", where, varname, var);
+    aisc_dump_hex("Hex: ", (const char*)&var, sizeof(var));
+}
+static void aisc_dump_long(const char *where, const char *varname, long var) {
+    fprintf(stderr, "AISC_DUMP: %s: long   %s=%li ", where, varname, var);
+    aisc_dump_hex("Hex: ", (const char*)&var, sizeof(var));
+}
+static void aisc_dump_double(const char *where, const char *varname, double var) {
+    fprintf(stderr, "AISC_DUMP: %s: double %s=%f ", where, varname, (float)var);
+    aisc_dump_hex("Hex: ", (const char*)&var, sizeof(var));
+}
+static void aisc_dump_charPtr(const char *where, const char *varname, const char *var) {
+    fprintf(stderr, "AISC_DUMP: %s: cPtr   %s='%s' ", where, varname, var);
+    aisc_dump_hex("Hex: ", var, strlen(var)+1);
+}
+static void aisc_dump_voidPtr2(const char *where, const char *varname, void *var) {
+    fprintf(stderr, "AISC_DUMP: %s: ptr    %s=%p\n", where, varname, var);
+}
+
+#define aisc_dump_voidPtr(w, n, v) aisc_dump_voidPtr2(w, n, (void*)v)
+#define AISC_DUMP(where, type, var) aisc_dump_##type(#where, #var, var)
+#define AISC_DUMP_SEP() fprintf(stderr, "-----------------------------\n")
+
+#else
+#define AISC_DUMP(where, type, var)
+#define AISC_DUMP_SEP()
+#endif // DUMP_COMMUNICATION
+
+// --------------------------------------------------------------------------------
+
+#else
+#error trace.h included twice
+#endif // TRACE_H
+