Initial repository layout

+2006-08-17 Georg Steffers [GST] <georg@steffers.org>
+
+	* src/stream_pool.c src/posix/stream_pool.c src/win32/stream_pool.c
+	  include/stream_pool.h include/posix/stream_pool.h 
+	  include/win32/stream_pool.h src/Makefile.am include/Makefile.am
+	  and various others (this is a major change):
+		  Sorry, this is in german and much to declarative...this was a
+		  thoughts-list that is now realized completely. I will rewrite it when
+		  i find the time.
+
+		  OK, ich fang mal wieder damit an meine Gedanken aufzunehmen.
+		  Das Problem das ich jetzt bekomme ist, das es streams unter
+		  windows nicht gibt...bzw. verschieden arten von streams unterschiedlich
+		  gehandhabt werden müssen. Hinzu kommt, das WaitForMultipleObject
+		  nur max. 64 Objekte werwalten kann. Will man mehr verwalten muß man
+		  das in mehreren streads tun.
+
+		  Daher muß ein stream_pool, anders als andere event listener nicht
+		  nur aus einem thread bestehen sondern aus einem pro 64 gleicher
+		  streams und einem Kontoll-Thread. (Hmm, für viele andere event listener
+				  gilt das gleiche, wenn ich unter Windows mehr als 64 Objekte 
+				  überwachen will. z.B. der fs_watcher. Gerade beim fs_watcher ist 
+				  es aber nun so, daß der unter Windows eh komplett anders 
+				  geschrieben werden muß.)
+
+		  Startet man einen stream_pool_listener, so wird der Kontroll Thread
+		  gestartet, welcher seinerseits alle weiteren threads startet.
+
+		  Added man einen stream, so muß zunächst nachgesehen werden ob es
+		  bereits einen <<stream pool>> für diesen stream_type gibt der außerdem
+		  noch nicht 64 streams enthält, falls es so einen stream pool gibt
+		  kann man den stream zu diesem hinzufügen, anderenfalls muß ein
+		  neuer stream pool angelegt werden.
+		  Nachdem der stream geadded wurde muß nur der stream pool, zu dem
+		  der stream hinzugefügt wurde neu gestartet werden.
+
+		  Will man einen stream aus einem stream pool entfernen, so muß dieser
+		  zunächst in allen stream pools gesucht werden, dann muß der thread
+		  zu dem stream pool in dem sich der stream befindet gestoppt werden
+		  woraufhin der stream entfernt werden kann. Danach muß der stream pool
+		  thread wieder gestartet werden.
+
+		  Für UNIX brauche ich nur einen einzige thread methode für alle stream
+		  pool typen, nämlich die, welche select nutzt.
+		  Für Windows muß ich je nach dem welcher Art von streams ein stream pool
+		  enthält unterschiedliche thread methoden nutzen:
+		  - select für sockets
+		  - WaitForMultipleObject für andere (Wie stell ich dabei fest was genau 
+				  mit dem Objekt passiert ist? OK, für pipes ist das Einfach, da es 
+				  eh ein Wege Kommunikation ist.)
+		  - und möglicherweise noch andere.

+DEFS = -DHAS_CONFIG @DEFS@
+
+ACLOCAL_AMFLAGS = -I m4
+
+EXTRA_DIST = config/config.rpath config/mkinstalldirs \
+				 include/scot_common.h \
+				 include/scot/stream_pool_fraction.h \
+				 include/scot/win32/thread.h \
+				 include/scot/win32/memory.h \
+				 include/scot/win32/dir.h \
+				 include/scot/win32/scot_types.h \
+				 include/scot/posix/thread.h \
+				 include/scot/posix/memory.h \
+				 include/scot/posix/dir.h \
+				 include/scot/posix/scot_types.h \
+				 src/win32/thread.c \
+				 src/win32/dir.c \
+				 src/win32/memory.c \
+				 src/win32/spf_thread_impl.c \
+				 src/win32/stream_ctl.c \
+				 src/posix/thread.c \
+				 src/posix/dir.c \
+				 src/posix/spf_thread_impl.c \
+				 src/posix/stream_ctl.c \
+				 design/scot-event-subsystem.dia 
+
+SUBDIRS = m4 include src src/po test test/po

+2006-08-07
+Es gibt noch einen bug im exception handling. Ich kann im Moment noch
+nicht genau sagen was passiert, evtl. ist es auch nur ein bug im testprogramm.
+Jedenfalls bekomme ich eine Fehlermeldung von wegen THROW kann nur in
+einem TRY-CATCH block aufgerufen werden wenn der stream_pool thread mit
+exit beendet.
+Ich weiß zur Zeit noch nicht ob dieser Fehler im Hauptthread oder im
+stream_pool thread passiert, ich vermute aber im Hauptthread, da der
+CATCH-Bereich des stream_pool threads ausgeführt wird.
+
+Möglicherweise ist das aber auch ein genereller Bug im exception system,
+der auftritt sobald man exit () in einem catch bereich nutzt. (Was eigentlich
+auch nicht wirklich ne gute Idee ist (meistens jedenfalls)...trotzdem sollte
+es möglich sein. im zweifelsfall durch eine eigene Funktion exc_exit oder so.
+
+OK, der richtige excenv stack sollte selectiert werden...daran liegts nicht.
+Trotzdem scheint es kein excenv mehr in diesem stack zu geben nachdem ich
+in den CATCH Block von scot_stream_pool_main_loop gekommen bin.
+
+AHA, die event_listener_fini methode throwed evtl. eine exception, und zwar
+ganau dann wenn sie von ihrem eigenen main loop aufgerufen wurde. Was
+hier passierte...allerdings schon aus dem CATCH Teil der main_loop
+methode, wodurch kein excenv mehr da war.
+Nachdem ich einen TRY-CATCH Block um den betreffenden Teil in
+event_listener_fini gemacht habe war das Problem behoben.
+
+--------------------
+
+Der fs_watcher code funktioniert so nicht. Man kann von dem notify descriptor
+leider nicht genau so lesen wie von einem file descriptor.
+Ich werde also code in scot stream integrieren, der die besonderheiten
+von inotify descriptoren berücksichtigt.
+Schließlich soll scot stream genau für sowas eine abstraction liefern.
+
+--------------------
+
+2006-08-23
+
+OK, fs-watcher mit inotify functioniert gröstenteils. Das heißt auf einer
+single cpu maschine läuft es problemlos, auf meiner alten SMP Maschine kommt
+der thread der die filesystem events überwacht ab und zu irgendwie in einen
+busy loop oder so was, jedenfalls reagiert er nicht mehr und zieht nahezu 
+100% CPU time auf einer CPU.
+
+---------------------
+
+Und hier jetzt der Knüller des Jahrhunderts.
+       ### select von winsock2 ist kein cancellation point ###
+      ### und (noch besser) kann nicht unterbrochen werden  ###
+Unerwartete und nervig. Seit Winsock2 ist select nicht mehr unterbrechbar. Das 
+macht es quasi unbrauchbar für threads wenn diese von Zeit zu Zeit unterbrochen
+werden sollen (z.B. damit der select in dem thread neu hinzugekommene 
+		Verbindungen mit überwacht), es sei denn man setzt die threads in einen 
+asynchronous mode. 
+Außerdem nuss ich multiple threads für die socket verwaltung verwenden, da
+windows select per default nur 64 sockets verwalten kann, was für einen server
+geradezu lächerlich wenig ist, also benutze ich pro 64 sockets einen thread.
+Im Moment suche ich nach einem Weg wie ich das Problem umgehen kann. Eine gute 
+Möglichkeit scheint zu sein, den socket an dem ich auf connections warte auch 
+in jedem select zu überwachen, dann sollte der select zurückkommen sobald eine 
+neue Verbindung hergestellt wird. 
+Dann muß nur noch sichergestellt sein das sich nur ein thread um die neu 
+ankommende Verbindung kümmert und das alle anderen solange warten bis der neue 
+socket in die zuständige socketliste eingetragen wurde. Das sollte aber mit 
+einer critical section kein Problem sein. 

+#!/bin/sh
+# Script for cleaning all autogenerated files.
+
+test ! -f Makefile || make distclean
+
+# Brought in by autopoint.
+rm -f ABOUT-NLS
+mv m4/ax_create_stdint_h.m4 .
+rm -f m4/*.m4
+mv ax_create_stdint_h.m4 m4
+rm -f src/po/Makefile.in.in
+rm -f src/po/remove-potcdate.sin
+rm -f test/po/Makefile.in.in
+rm -f test/po/remove-potcdate.sin
+
+# Generated by aclocal.
+rm -f aclocal.m4
+
+# Generated by autoconf.
+rm -f configure
+
+# Generated by autoheader
+rm -f config.h.in
+
+# Generated or brought in by automake.
+rm -f Makefile.in
+rm -f m4/Makefile.in
+rm -f src/Makefile.in
+rm -f test/Makefile.in
+rm -f include/Makefile.in
+rm -f INSTALL
+rm -f COPYING
+
+# Generated by all in config
+rm -rf config
+
+rm -rf autom4te.cache
+
+# Generated by testruns
+find . -name exc_test.fil -exec rm -f {} \;
+
+# Generated by doxygen
+rm -f doxy.wrn
+rm -rf doc/full/*
+rm -rf doc/usage/*

+#!/bin/sh
+# Script for regenerating all autogenerated files.
+
+autopoint -f # was: gettextize -f -c
+cp po/Makefile.in.in       src/po
+cp po/remove-potcdate.sin  src/po
+cp po/Makefile.in.in       test/po
+cp po/remove-potcdate.sin  test/po
+rm -fR po
+
+aclocal -I m4
+autoconf
+autoheader
+libtoolize -c -f
+automake -a -c

+AC_PREREQ(2.59)
+AC_INIT(scot, 0.0.3, BUG-REPORT-ADDRESS)
+AC_CONFIG_AUX_DIR([config])
+AC_CONFIG_SRCDIR([src/cmdla.c])
+AC_CONFIG_HEADER([config.h])
+AM_INIT_AUTOMAKE
+
+AC_CANONICAL_HOST
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_MAKE_SET
+AC_LIBTOOL_WIN32_DLL
+AC_PROG_LIBTOOL
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([getopt.h libintl.h locale.h stdlib.h string.h unistd.h wchar.h])
+AX_CREATE_STDINT_H([include/scot/scot_int.h])
+
+
+# Checks for libraries.
+AM_GNU_GETTEXT([external])
+AC_MSG_CHECKING([intl])
+AC_MSG_RESULT([$LIBINTL])
+AM_GNU_GETTEXT_VERSION(0.13.1)
+localedir=`eval echo $datadir/locale`
+AC_DEFINE_UNQUOTED(LOCALEDIR, "$localedir", [Name of gettext locale directory])
+THREAD_LIB=
+THREAD_CFLAGS=
+AC_MSG_CHECKING([for Win32])
+case "$host" in
+   *-*-mingw*)
+      win32="yes, use windows threads"
+      pthread="pthreadGC2"
+      SOCK_LIB="-lws2_32"
+      ;;
+   *)
+      win32="no"
+      pthread="pthread"
+      SOCK_LIB=""
+      ;;
+esac
+AC_MSG_RESULT([$win32])
+
+AC_CHECK_LIB($pthread,pthread_create,
+             THREAD_LIB=-l$pthread
+             THREAD_CFLAGS="-DUSE_PTHREAD -DREENTRANT"
+	     thread="PTHREAD",
+	     THREAD_CFLAGS="-DUSE_WTHREAD"
+	     thread="WTHREAD",)
+
+AC_SUBST(SOCK_LIB)
+AC_SUBST(THREAD_LIB)
+AC_SUBST(THREAD_CFLAGS)
+
+AM_CONDITIONAL(USE_THREADS, test "x$thread" != "x")
+AM_CONDITIONAL(PTHREAD,     test "x$thread" == "xPTHREAD")
+AM_CONDITIONAL(WTHREAD,     test "x$thread" == "xWTHREAD")
+AM_CONDITIONAL(WIN32,       test "x$win32" != "xno")
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+
+# Checks for library functions.
+AC_CHECK_FUNCS([memset setlocale])
+
+dnl We need to check if the right inotify version is accessible
+use_inotify="yes"
+AC_MSG_CHECKING([whether inotify is to be used for filemonitoring])
+
+if test "x$win32" == "xno"
+then
+ AC_ARG_ENABLE(inotify, 
+  [  --disable-inotify             disable inotify in the ecore_file module],
+  [
+ 	if test "$enableval" == "yes"; then  
+ 	  AC_MSG_RESULT([yes])
+ 	else
+ 	  AC_MSG_RESULT([no - but we need it])
+ 	  use_inotify="no"
+ 	fi
+  ], [
+ 	AC_MSG_RESULT([yes])
+  ]
+ )
+ 
+ dnl It's hard to find a good test on how to check the correct
+ dnl inotify version. They changed the headers a lot.
+ dnl in kernel 2.6.13 __NR_inotify_init was added to the defined syscalls
+ dnl in asm/unistd.h and IN_MOVE_SELF was added to linux/inotify.h
+ dnl so with this check you need a very new kernel and kernel-headers!
+ dnl On my gentoo, /usr/include/asm and /usr/include/linux are no symlinks
+ dnl into the current kernel tree....so i also try to find the includes
+ dnl under /usr/src/linux or under /usr/include/linux-`uname -r`
+ linux_rev=`uname -r`
+ INOTIFY_INCLUDES=
+ AC_MSG_CHECKING([for sufficient inotify includes])
+ if test "x$use_inotify" = "xyes"; then
+  AC_TRY_COMPILE(
+ 	[
+ 	  #include <asm/unistd.h>
+ 	  #include <linux/inotify.h>
+ 	],
+ 	[ int a = __NR_inotify_init; int b = IN_MOVE_SELF; ],
+ 	[
+ 	  AC_DEFINE(HAVE_INOTIFY, 1, [ File monitoring with Inotify ])
+ 	  an_inc=/usr/include
+ 	], 
+ 	[
+      AC_TRY_COMPILE(
+ 	    [
+ 	      #include "/usr/src/linux/include/asm/unistd.h"
+ 	      #include "/usr/src/linux/include/linux/inotify.h"
+ 	    ],
+ 	    [ int a = __NR_inotify_init; int b = IN_MOVE_SELF; ],
+ 	    [
+ 	      AC_DEFINE(HAVE_INOTIFY, 1, [ File monitoring with Inotify ])
+ 			AC_DEFINE(IN_KERNEL, 1, [ blablabla ])
+ 	      INOTIFY_INCLUDES=-I/usr/src/linux/include
+ 			an_inc=/usr/src/linux/include
+ 		 ],
+ 	    [
+          AC_TRY_COMPILE(
+ 	        [
+ 	          #include </usr/src/linux-$linux_rev/include/asm/unistd.h>
+ 	          #include </usr/src/linux-$linux_rev/include/linux/inotify.h>
+ 	        ],
+ 	        [ int a = __NR_inotify_init; int b = IN_MOVE_SELF; ],
+ 	        [
+ 	          AC_DEFINE(HAVE_INOTIFY, 1, [ File monitoring with Inotify ])
+ 				 AC_DEFINE(IN_KERNEL_UNAME, 1, [ blablabla ])
+ 	          INOTIFY_INCLUDES=-I/usr/src/linux-$linux_rev/include
+ 				 an_inc=/usr/src/linux-$linux_rev/include
+ 			  ],
+ 	        [
+ 	          use_inotify="no"
+ 				 an_inc="not found"
+ 		     ]
+ 			)
+ 		 ]
+ 	  )
+ 	]
+  )
+  AC_MSG_RESULT([$an_inc])
+  test "x$an_inc" == "xnot found" && exit
+ else
+  AC_MSG_RESULT(["Not used"])
+ fi
+
+ AC_SUBST(INOTIFY_INCLUDES)
+else
+ use_inotify="no"
+ AC_MSG_RESULT([no])
+fi
+
+AM_CONDITIONAL(USE_INOTIFY, test "x$use_inotify" != "xno")
+
+
+AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([src/Makefile])
+AC_CONFIG_FILES([include/Makefile])
+AC_CONFIG_FILES([test/Makefile])
+AC_CONFIG_FILES([m4/Makefile])
+AC_CONFIG_FILES([src/po/Makefile.in])
+AC_CONFIG_FILES([test/po/Makefile.in])
+
+AC_OUTPUT

+#include <stdio.h>
+#include <scot/scot_int.h>
+#include <scot/event.h>
+#include <scot/thread.h>
+
+#define GEN_LOCAL
+#include <scot/list.h>
+#include <scot/queue.h>
+#undef  GEN_LOCAL
+
+struct scot_event_manager;
+
+struct scot_event_source
+{
+	struct scot_event_manager *  manager;
+	unsigned int                 group;
+	THREAD_T                     sthr;
+	scot_event_source_entry_fptr event_source_thread_entry;
+
+	int (*event_done_cb) (struct scot_event *);
+};
+
+/*
+ * das ist cool, mit folgender Struktur und der Tatsache das die registrierten
+ * callbacks in einer Instanz dieser Struktur und dann in einer liste
+ * gespeichert werden bedeutet, das ich mehrere callback zu einem event
+ * registrieren kann. Im moment würden diese dann in undefinierter
+ * Reihenfolge aufgerufen, sobald ein event auftaucht.
+ * Sobald der tree code fertig ist sollte man die callbacks in einem
+ * balanced b-tree speichern bei dem der key die event-nummer ist.
+ * Das würde die zugriffe auf die callbacks nochmal erheblich beschleunigen.
+ * Vorher könnte man sich überlegen callbacks sortiert einzufügen.
+ * (Warscheinlich würde das auch schon reichen, da callbacks normalerweise
+ * nur einmal zu beginn des Programms registriert werden und daher die
+ * insert-zeit nicht so relevant ist.)
+ */
+struct scot_event_cb
+{
+	uint32_t event;
+	int (*cb) (struct scot_event *); /* wenn ein cb 0 zurückliefert werden
+													keine weiteren registrierten 
+													callbacks zu diesem event ausgeführt,
+													sonst so lange bis keine weiteren
+													events vorliegen. */
+};
+typedef struct scot_event_cb scot_event_cb_t;
+GEN_LIST (scot_event_cb_t);
+
+struct scot_event_sink
+{
+	struct  scot_event_manager *  manager;
+	unsigned int                  group;
+	uint32_t                      mask;
+
+	list_scot_event_cb_t_node_t * cb_mappings;
+};
+
+
+typedef struct scot_event scot_event_t;
+GEN_QUEUE (scot_event_t);
+
+
+struct scot_event_manager
+{
+	struct scot_event_source sources [32];
+	struct scot_event_sink   sinks   [32];
+
+	queue_scot_event_node_t *         queue;
+};
+
+
+/*
+ * Funktionen zum manager
+ */
+struct scot_event_manager * 
+scot_event_manager_new (void);
+
+int
+scot_event_manager_register_source (
+		struct scot_event_manager *,
+		struct scot_event_source *);
+
+int scot_event_manager_register_cb (
+		struct scot_event_manager *,
+		uint32_t event,
+		int (*cb) (struct scot_event *));
+
+/*
+ * Funktionen zur source
+ */
+struct scot_event_source * 
+scot_event_source_init (
+		unsigned int group,
+		int (*event_done_cb) (struct scot_event *));
+
+int
+scot_event_source_register (
+		struct scot_event_source *);
+
+/*
+ * Funktionen zur sink
+ */

+nobase_include_HEADERS = scot/cmdla.h \
+						scot/list.h scot/list_impl.h scot/list_proto.h \
+						scot/list_man.h scot/list_mod.h scot/list_nav.h \
+						scot/list_type_proto.h scot/list_func_proto.h \
+						scot/stack.h scot/stack_impl.h scot/stack_proto.h \
+						scot/stack_type_proto.h scot/stack_func_proto.h \
+						scot/queue.h scot/queue_impl.h scot/queue_proto.h \
+						scot/queue_type_proto.h scot/queue_func_proto.h \
+						scot/exception.h scot/exception_t.h scot/excenv_t.h \
+						scot/thread.h scot/memory.h scot/dir.h scot/dir_common.h \
+						scot/scot_exceptions.h scot/scot_types.h \
+						scot/socket.h scot/socket_in.h \
+						scot/event.h scot/event_listener.h \
+						scot/fs_watcher.h \
+						scot/stream.h scot/stream_pool.h
+
+BUILT_SOURCES = scot/thread.h scot/memory.h scot/dir.h
+CLEANFILES    = scot/thread.h scot/memory.h scot/dir.h
+
+if PTHREAD
+scot/thread.h: Makefile scot/posix/thread.h
+	cp scot/posix/thread.h scot/thread.h
+else
+scot/thread.h: Makefile scot/win32/thread.h
+	cp scot/win32/thread.h scot/thread.h
+endif
+
+if WIN32
+nobase_include_HEADERS += scot/stream_win.h
+
+scot/scot_types.h: Makefile scot/win32/scot_types.h
+	cp scot/win32/scot_types.h scot/scot_types.h
+scot/memory.h: Makefile scot/win32/memory.h
+	cp scot/win32/memory.h scot/memory.h
+scot/dir.h: Makefile scot/win32/dir.h
+	cp scot/win32/dir.h scot/dir.h
+else
+nobase_include_HEADERS += scot/socket_un.h scot/inotify.h
+
+scot/scot_types.h: Makefile scot/posix/scot_types.h
+	cp scot/posix/scot_types.h scot/scot_types.h
+scot/memory.h: Makefile scot/posix/memory.h
+	cp scot/posix/memory.h scot/memory.h
+scot/dir.h: Makefile scot/posix/dir.h
+	cp scot/posix/dir.h scot/dir.h
+endif
+

+/*
+ * cmdla.h: Prototypes, defines, etc. for cmdla
+ *
+ * Copyright (C) 2006 Georg Steffers. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU Genral Public
+ * License (GPL). Please see gpl.txt for details or refer to 
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * Author: Georg Steffers <georg@steffers.org>
+ *
+ * 01/14/2006: Georg Steffers - First implemented
+ * 01/15/2006: Georg Steffers - V0.1 ready. Modified this and that
+ *                              now long arguments are supported as
+ *                              well as arguments with am optional
+ *                              parameter.
+ * 01/23/2006: Georg Steffers - add support for gettext.
+ */
+
+#ifndef CMDLA_H
+#define CMDLA_H
+
+/* Datatypes of given commandline values */
+#define CMDLA_TYPE_STRING  0x00
+#define CMDLA_TYPE_INT     0x01
+#define CMDLA_TYPE_FLOAT   0x02
+
+/* Indicates wether an arg requires an parameter or not */
+#define CMDLA_REQ_ARG      0x01
+#define CMDLA_OPT_ARG      0x02
+
+#define CMDLAP_CBT_END     { 0, NULL, 0, NULL, 0, NULL, NULL }
+#define CMDLAS_CBT_END     { 0, NULL, NULL, NULL, NULL }
+
+#define _GNU_SOURCE        /* for getopt */
+
+#include <unistd.h>
+#include <wchar.h>
+#include <getopt.h>
+
+#include <scot_common.h>
+
+/*
+ * This struct holds all neccesary infomation for the default
+ * usage callback. It is filled within process_cmd_line and used
+ * with any usage function that did not specify explicitly different
+ * behaviour.
+ */
+struct du_infot
+{
+   const struct cmdlas_cbt *switches;
+   const struct cmdlap_cbt *arguments;
+   const char              *about;
+   const char              *copyright;
+   const char              *usage_aa;
+   const char              *program_name;
+};
+
+
+typedef int (*cmdlap_cb)  (const char *, const int, void *);
+typedef int (*cmdlas_cb)  (void *);
+
+/* 
+ * CoMmanDLine Argument Parameter CallBack Type.
+ * This holds the definition of an argument that takes a parameter.
+ */
+struct cmdlap_cbt {
+   char        carg;             /* The single letter argument e.g. -a */
+   char        *sarg;            /* The string argument e.g. --arg */
+   int         cmdla_argt;       /* Datatype the arg take e.g. CMDLA_TYPE_INT */
+   cmdlap_cb   cb;               /* pointer to the callback funtion */
+   int         cmdla_type;       /* requires parameter? e.g. CMDLA_REQ_ARG */
+   void        *var;             /* this will be given to the callback */
+   const char  *info;            /* a short description for the help */
+};
+
+/* 
+ * CoMmanDLine Argument Switch CallBack Type.
+ * This holds the definition of an argument that is a switch.
+ */
+struct cmdlas_cbt {
+   char        carg;             /* The single letter argument e.g. -a */
+   char        *sarg;            /* The string argument e.g. --arg */
+   cmdlas_cb   cb;               /* pointer to the callback funtion */
+   void        *var;             /* this will be given to the callback */
+   const char  *info;            /* a short description for the help */
+};
+
+
+/*
+ * The defaul usage method....this was previously static within
+ * cmdla but i realised that it is useful to make it callable
+ * within the calling code to do special usage in special cases
+ * and call this if no special case occured.
+ */
+int   default_usage_cb  (void *);
+
+/* 
+ * a default callback for struct cmdlap_cbt. It simply parses its first
+ * argument into its last according to the type specified by its sec. arg.
+ */
+int   get_cmdlap_cb     (const char *, const int, void *);
+
+/*
+ * this does all the work. 
+ * Arguments are: (argc, argv, a program description, a copyright string, 
+ * additional text for the usage information, 
+ * a list of arguments with parameter, a list of switches).
+ */
+int   process_cmd_line  (
+      int, char *[], const char*, const char*, const char*,
+      const struct cmdlap_cbt *, const struct cmdlas_cbt *);
+
+int   switch_cb         (void *);
+int   inc_cb            (void *);
+
+#endif /* CMDLA_H */

+/*
+ * dir_common.h: definitions and prototypes common for all plattforms with
+ *               dir.c
+ *
+ * Copyright (C) 2006 Georg Steffers
+ *
+ * Author:    Georg Steffers [GST] <georg.steffers@aschendorff.de>
+ * Developer:
+ *
+ * Changes (for this file only):
+ *   (2006-06-12) [GST] Started this changelog...well the program is
+ *                      ready since some weeks right now.
+ */
+#ifndef DIR_COMMON_H
+#define DIR_COMMON_H
+
+/* return values for get_dir_next */
+#define GET_DIRENT_OK   0x00
+#define NO_FILES_LEFT   0x01
+#define GET_DIRENT_ERR  0x02
+
+/* flags for symlink following */
+#define FOLLOW_SYM      0x00
+#define DONT_FOLLOW_SYM 0x01
+
+#endif /* DIR_COMMON_H */

+#ifndef SCOT_EVENT_H
+#define SCOT_EVENT_H
+
+#include <stddef.h>
+
+#include <scot/scot_int.h>
+#include <scot/scot_types.h>
+
+#define SCOT_EVENT_NO		uint16_t
+
+/*
+ * basis event struktur. Ein Typ und die wirkliche größe.
+ */
+struct scot_event
+{
+	SCOT_EVENT_NO event;
+	uint32_t      size;       /* is used with serialization. If an event
+										  was serialized and send over a datalink,
+										  it is possible that not all data is read
+										  at once. So i can first read 
+										  sizeof (struct scot_event) and then i
+										  know exactly how much has to be read for
+										  the whole event. */
+	uint32_t      ed_size;    /* This reflects the size of the extra_data
+										  buffer...when serializing is done it is
+										  neccessary to know where extra_data ends,
+										  and as it could be any arbitrary data this
+										  could not be guessed by the code. */
+	void *        extra_data; /* maybe this should hold the object that
+										  an callback function to this event belongs
+										  to. */
+};
+
+
+struct scot_event * scot_event_new         (struct scot_event *, 
+		                                      SCOT_EVENT_NO , void *, SIZE_T);
+SIZE_T              scot_event_serialize   (struct scot_event *, char **);
+struct scot_event * scot_event_deserialize (struct scot_event *, const char *);
+void                scot_event_free        (struct scot_event *);
+
+/*
+ * event definitionen für stream pool events
+ * Die stream pool event gruppe hat nur eine erweiterte event struktur,
+ * es ist aber auch denkbar das eine event gruppe mehrere solche strukturen
+ * einschließt. (Alle events die ein stream pool erzeugt  sind read
+ * write oder exception auf einem stream und fuer alle diese events
+ * reicht es den stream handle im event mitzugeben).
+ */
+struct scot_stream_pool_event
+{
+	struct scot_event         event;
+	struct scot_stream *      st;
+};
+
+struct scot_stream_pool_event * scot_stream_pool_event_new (
+		struct scot_stream_pool_event *,
+		SCOT_EVENT_NO, void *, SIZE_T, struct scot_stream * );
+
+/*
+ * event definitionen für filesystem watcher events
+ */
+struct scot_fs_watcher_event
+{
+	struct scot_event event;
+	char *            path;
+	char *            name;
+	char *            oldname; /* used by rename events */
+};
+
+struct scot_fs_watcher_event * scot_fs_watcher_event_new (
+		struct scot_fs_watcher_event *,
+		SCOT_EVENT_NO, void *, SIZE_T, 
+		const char *, const char *, const char *);
+
+#define GEN_SCOT_EVENT_NO (group, mask, no) ((group<<24)&(mask<<18)&no)
+#define SCOT_EVENT_GEN_MASK(exp)            1<<(exp)
+
+#define SCOT_EVENT_CHK_GROUP(e, g) (((e)&((SCOT_EVENT_NO)(g)<<8)) == ((g)<<8))
+
+/* EG := EVENT_GROUP */
+#define SCOT_EG_INTERNAL          ((SCOT_EVENT_NO)0)
+#define SCOT_EG_STREAM_POOL       ((SCOT_EVENT_NO)1)
+#define SCOT_EG_FS_WATCHER        ((SCOT_EVENT_NO)2)
+
+#define SCOT_EVENT_STREAM_POOL_READ   \
+	((SCOT_EVENT_NO)(SCOT_EG_STREAM_POOL << 8) | 0)
+#define SCOT_EVENT_STREAM_POOL_WRITE  \
+	((SCOT_EVENT_NO)(SCOT_EG_STREAM_POOL << 8) | 1)
+#define SCOT_EVENT_STREAM_POOL_EXCEP  \
+	((SCOT_EVENT_NO)(SCOT_EG_STREAM_POOL << 8) | 2)
+
+#define SCOT_EVENT_FS_WATCHER_CREATE \
+	((SCOT_EVENT_NO)(SCOT_EG_FS_WATCHER << 8) | 0)
+#define SCOT_EVENT_FS_WATCHER_DELETE \
+	((SCOT_EVENT_NO)(SCOT_EG_FS_WATCHER << 8) | 1)
+#define SCOT_EVENT_FS_WATCHER_RENAME \
+	((SCOT_EVENT_NO)(SCOT_EG_FS_WATCHER << 8) | 2)
+#define SCOT_EVENT_FS_WATCHER_WRITTEN \
+	((SCOT_EVENT_NO)(SCOT_EG_FS_WATCHER << 8) | 3)
+#define SCOT_EVENT_FS_WATCHER_ATTRCHG \
+	((SCOT_EVENT_NO)(SCOT_EG_FS_WATCHER << 8) | 4)
+#define SCOT_EVENT_FS_WATCHER_SIZECHG \
+	((SCOT_EVENT_NO)(SCOT_EG_FS_WATCHER << 8) | 5)
+
+
+#endif /* SCOT_EVENT_H */

+#ifndef _SCOT_EVENT_LISTENER_H
+#define _SCOT_EVENT_LISTENER_H
+
+#include <limits.h>
+
+#include <scot/scot_int.h>
+#include <scot/event.h>
+#include <scot/thread.h>
+
+#include <scot/stack_type_proto.h>
+
+/* valid return codes for the callbacks */
+#define SCOT_EVENT_END                 0x00
+#define SCOT_EVENT_CONT                0x01
+#define SCOT_EVENT_CONT_DATA_DONE		0x02
+
+#define SCOT_EL_WAIT_THREAD_MAX        INFINITE
+
+
+typedef unsigned short (*scot_event_cb_fptr) (struct scot_event *);
+
+GEN_STACK_TYPE_PROTO (scot_event_cb_fptr);
+
+struct scot_event_listener
+{
+	unsigned char                     group;
+
+	stack_scot_event_cb_fptr_node_t * cb_mappings[UCHAR_MAX];
+	void *                            cb_extra_data[UCHAR_MAX];
+
+	THREAD_T                          thread_handle;
+	THREAD_ID_T                       thread_id;
+	int                               thread_run_flg;
+
+	scot_thread_entry_fptr            el_entry_func;
+};
+typedef struct scot_event_listener scot_event_listener;
+
+void scot_event_listener_init        (struct scot_event_listener *,
+                                      const unsigned char         ,
+                                      const scot_thread_entry_fptr);
+void scot_event_listener_fini        (struct scot_event_listener *);
+void scot_event_listener_start       (struct scot_event_listener *);
+void scot_event_listener_stop        (struct scot_event_listener *);
+int  scot_event_listener_is_running  (struct scot_event_listener *);
+void scot_event_listener_register_cb (struct scot_event_listener *,
+                                      SCOT_EVENT_NO               ,
+                                      scot_event_cb_fptr          ,
+												  void *);
+void scot_event_listener_call_cb     (struct scot_event_listener *, 
+                                      struct scot_event *);
+
+#endif /* _SCOT_EVENT_LISTENER_H */

+/**
+ * \file    scot/excenv_t.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   The datatypes for exception environments.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_EXCENV_T_H
+#define  STACK_EXCENV_T_H
+
+#include <setjmp.h>
+
+#include <scot/exception_t.h>
+
+struct excenv_t;
+typedef struct excenv_t excenv_t;
+
+#ifndef  USE_SCOT_STRUCT_EXCENV_T
+struct excenv_t
+{
+   const char _ [sizeof (struct {
+      jmp_buf  env;
+      void     *e_queue;
+      })];
+};
+#else
+/**
+ * \internal
+ * \brief holds an exception environment.
+ */
+struct excenv_t
+{
+   jmp_buf                    env;        /**< jump here on error. */
+   queue_exception_t_node_t   *e_queue;   /**< holds the exceptions. */
+};
+#endif
+
+#endif   /* STACK_EXCENV_T_H */

+/**
+ * \file    scot/exception.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   The user interface to exception handling.
+ *
+ * This describes the macros TRY, CATCH, THROW and EXC.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  EXCEPTION_H
+#define  EXCEPTION_H
+
+#include <setjmp.h>
+
+#include "excenv_t.h"
+#include "exception_t.h"
+#include <scot/thread.h>
+
+
+#ifdef   USE_THREADS
+#  define   EXC_INIT    threaded_exc_init
+#else
+#  define   EXC_INIT    exc_init
+#endif   /* USE_THREADS */
+
+/**
+ * \pre     None
+ * \return  Nothing
+ * \post    a current exception environment exists.
+ *
+ * \brief   start exception handled code.
+ *
+ * This starts a block of exception handled code. This is done by
+ * creating a current exception environment.
+ */
+#define  TRY                                                      \
+   {                                                              \
+      excenv_new (EXC_INIT ());                                   \
+      if (setjmp (* excenv_jmp_buf (EXC_INIT ())) == 0)
+
+/**
+ * \param   ee will hold the exception environment actually handled.
+ * \pre     a current exception environment must exists.
+ * \return  Nothing
+ * \post    ee holds the current exception environment and it is removed
+ *          from the stack of exception environments.
+ *
+ * \brief   start exception handling.
+ *
+ * This starts a block of exception handling. This is done by
+ * retrieving the actual exception environment into \a ee.
+ */
+#define  CATCH(ee)                                                \
+      ee = excenv_catch (EXC_INIT ());                            \
+   }                                                              \
+   if (excenv_has_exception(ee) == 0)                             \
+      free_catched (ee);                                          \
+   else
+
+/**
+ * \param   e the exception to be thrown.
+ * \pre     a current exception environment must exist.
+ * \return  Nothing
+ * \post    \a e is put into the current exception environment.
+ *
+ * \brief   Throws an exception into the actual exception environment.
+ */
+#define  THROW(e)                                                 \
+   exc_throw (EXC_INIT (), (e))
+
+/**
+ * \brief this is just a wrapper around exc_new().
+ *
+ * This is just a wrapper around exc_new() that fills in automatically
+ * file and line.
+ */
+#define  EXC(lvl, errnum, err_msg)                                \
+   exc_new (lvl, __FILE__, __LINE__, errnum, err_msg)
+
+/**
+ * \brief   a wrapper for exc_in_this_try()
+ */
+#define  EXC_IN_THIS_TRY(e)                                       \
+   exc_in_this_try (e)
+
+void *      exc_init           ();
+void *      threaded_exc_init  ();
+
+void        excenv_new           (void *);
+jmp_buf *   excenv_jmp_buf       (void *);
+void        exc_throw            (void *, const exception_t *);
+excenv_t *  excenv_catch         (void *);
+int         excenv_has_exception (const excenv_t *);
+
+exception_t *  exc_new           (
+      const enum exclvl_t, 
+      const char *,
+      const int,
+      const int, 
+      const char *);
+
+exception_t *  retrive_exception       (const excenv_t *);
+
+void           free_catched            (excenv_t *);
+void           free_exception          (exception_t *);
+void           thread_exc_end          (THREAD_T);
+void           exc_end                 (void);
+
+void           print_exception         (exception_t *);
+void           print_all_exceptions    (excenv_t *);
+void           forward_all_exceptions  (excenv_t *);
+
+int            exc_in_this_try         (exception_t *);
+enum exclvl_t  exc_lvl_get             (exception_t *);
+char *         exc_file_get            (exception_t *);
+int            exc_line_get            (exception_t *);
+int            exc_errnum_get          (exception_t *);
+char *         exc_err_msg_get         (exception_t *);
+#endif   /* EXCEPTION_H */

+/**
+ * \file    scot/exception_t.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   The datatypes for exceptions.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_EXCEPTION_T_H
+#define  STACK_EXCEPTION_T_H
+
+/**
+ * \brief give the two states a speaking name.
+ *
+ * There are two exceptions possible EXC_ERRORS, that immediatly abort the
+ * current operation and EXC_WARNINGS, that will just be mentioned within
+ * the exception stack.
+ */
+enum exclvl_t {EXC_WARNING, EXC_ERROR};
+
+struct exception_t;
+typedef struct exception_t exception_t;
+
+#ifndef  USE_SCOT_STRUCT_EXCEPTION_T
+struct exception_t
+{
+   const char _ [sizeof (struct {
+               int            was_catched;
+         const enum exclvl_t  lvl;
+         const char           *file;
+         const int            line;
+         const int            errnum;
+         const char           *err_msg;
+         })];
+};
+#else
+/**
+ * \internal
+ * \brief holds an exception.
+ */
+struct exception_t
+{
+         int            was_catched; /**< how often was it catched */
+   const enum exclvl_t  lvl;         /**< EXC_ERROR or EXC_WARNING */
+   const char           *file;       /**< file where it was created */
+   const int            line;        /**< line of that file */
+   const int            errnum;      /**< number of the error */
+   const char           *err_msg;    /**< message of the error */
+};
+
+#include <scot/queue_type_proto.h>
+GEN_QUEUE_TYPE_PROTO (exception_t);
+#endif
+
+#endif   /* STACK_EXCEPTION_T_H */

+#ifndef SCOT_FS_WATCHER_H
+#define SCOT_FS_WATCHER_H
+
+#include <scot/event_listener.h>
+#include <scot/thread.h>
+#include <scot/stream.h>
+
+#include <scot/list_type_proto.h>
+
+struct scot_fsw_info
+{
+	int      watch_d;
+	char *   path;
+	uint32_t mask;
+	uint32_t got_events; /* also a mask, that shows, which events already
+									occured (will be 0 at init and after a callback was
+									called.) */
+	char *   old_name;   /* This is used within rename events. With inotify
+									a rename is build up from 2 inotify_events.
+									IN_MOVE_FROM and IN_MOVE_TO. The move from
+									event holds the old name. This old name is saved
+									here if an IN_MOVE_FORM occured. */
+};
+typedef struct scot_fsw_info scot_fsw_info;
+GEN_LIST_TYPE_PROTO (scot_fsw_info);
+
+struct scot_fs_watcher
+{
+	struct scot_event_listener el;
+	fd_set rfds;
+	struct scot_stream notify_d;
+
+	list_scot_fsw_info_node_t * w_list;
+	THREAD_MUTEX_T mutex;
+};
+
+
+struct scot_fs_watcher * scot_fs_watcher_new  (void);
+void                     scot_fs_watcher_free (struct scot_fs_watcher *);
+
+void scot_fs_watcher_add    (struct scot_fs_watcher *, const char *, uint32_t);
+void scot_fs_watcher_remove (struct scot_fs_watcher *, const char *, uint32_t);
+
+int  scot_fs_watcher_get_mask  (struct scot_fs_watcher *, int);
+void scot_fs_watcher_main_loop (struct scot_fs_watcher *);
+
+#endif /* SCOT_FS_WATCHER_H */

+#ifndef INOTIFY_H
+#define INOTIFY_H
+
+#include <sys/syscall.h>
+#include <asm/unistd.h>
+#include <sys/types.h>
+#include <linux/inotify.h>
+
+#define IN_NEXT_EVENT(ev)   \
+	(struct inotify_event *) \
+	((char *)(ev) + sizeof (struct inotify_event) + (ev)->len)
+
+#define IN_NO_EVENT(ev)		((ev)->mask|IN_ALL_EVENTS) == IN_ALL_EVENTS
+
+
+static inline int inotify_init (void)
+{
+   return syscall (__NR_inotify_init);
+}
+
+static inline int inotify_add_watch (int fd, const char *name, __u32 mask)
+{
+   return syscall (__NR_inotify_add_watch, fd, name, mask);
+}
+
+static inline int inotify_rm_watch (int fd, __u32 wd)
+{
+   return syscall (__NR_inotify_rm_watch, fd, wd);
+}
+
+#endif /* INOTIFY_H */

+/**
+ * \file scot/list.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro which produce all prototypes and implementations 
+ *          for handling linked lists from Templates.
+ *
+ * This is the toplevel template file for typesafe lists. It is quite
+ * simple. It just defines one MACRO which in turn calls two other macros
+ * to generate all that is needed for listhandling of a list to a given type.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_H
+#define  LIST_H
+
+#include <scot/list_proto.h>
+#include <scot/list_impl.h>
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The complete framework of functions, types, globals
+ *                   prototypes and definitions to handle typesave
+ *                   lists for the given datatype are generated within the
+ *                   calling build file.
+ *
+ * \brief create complete framework to handle typesafe lists.
+ *
+ * This macro first colls GEN_LIST_PROTO() to create all prototypes
+ * neccesary for handling lists of the given \a type. And then it calls
+ * GEN_LIST_IMPL() to also create the neccesary definitions and
+ * implementations.\
+ * Normally this macro is only called if one only wants to have lists
+ * of the given type in a single c source file and nowhere else. Normally
+ * this is then used in conjunction with a previous define of GEN_LOCAL, 
+ * that tells GEN_LIST() and the subsequent macros to generate the functions
+ * as static.\n
+ * If one wants to used lists of the given type in several places of the
+ * project one would normally call GEN_LIST_PROTO() in a h file and 
+ * GEN_LIST_IMPL() in the corresponding c file (without GEN_LOCAL),
+ */
+#define  GEN_LIST(type)                            \
+   GEN_LIST_PROTO (type)                           \
+   GEN_LIST_IMPL (type)
+
+#endif   /* LIST_H */

+/**
+ * \file scot/list_func_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro that produce function prototypes for handling 
+ *          linked lists.
+ *
+ * The macros here create all function prototypes to 
+ * the implementations created by the macros in 
+ * \link scot/list_impl.h scot/list_impl.h\endlink.
+ * These macros are normally not called directly within your code but
+ * through \link scot/list_proto.h::GEN_LIST_PROTO GEN_LIST_PROTO\endlink. 
+ * This is because to use the interface declaration
+ * provided here one will also need the typedefs and datatype prototypes.
+ * 
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_FUNC_PROTO_H
+#define  LIST_FUNC_PROTO_H
+
+#ifdef   GEN_LOCAL
+#  define   STATIC   static
+#else
+#  define   STATIC
+#endif
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The function prototypes for manage lists of the given 
+ *                   datatype are created.
+ *
+ * \brief Function prototypes for management.
+ *
+ * This creates the prototypes to the functions that are created by
+ * \link scot/list_man.h::GEN_LIST_MANAGEMENT GEN_LIST_MANAGEMENT\endlink 
+ * in \link scot/list_man.h scot/list_man.h\endlink.
+ *
+ * Normally this is not called directly, but by 
+ * \link scot/list_proto.h::GEN_LIST_PROTO GEN_LIST_PROTO()\endlink 
+ * because this defined just a subset of all function prototypes neccesarry 
+ * to handle typesafe lists.
+ */
+#define  GEN_LIST_MAN_PROTO(type)                                    \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _set_cmp        (                                \
+         list_ ## type ## _cmp_fptr);                                \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _set_elem_free  (                                \
+         list_ ## type ## _elem_free_fptr);                          \
+   STATIC                                                            \
+   long                                                              \
+   list_ ## type ## _elem_free_is_set  (void);                       \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _new            (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _free           (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _count          (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _bol            (                                \
+         list_ ## type ## _node_t *,                                 \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _eol            (                                \
+         list_ ## type ## _node_t *anchor,                           \
+         list_ ## type ## _node_t *node);
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The function prototypes to navigate lists of the given 
+ *                   datatype are created.
+ *
+ * \brief Function prototypes for navigation.
+ *
+ * This creates the prototypes to the functions that are created by
+ * \link scot/list_nav.h::GEN_LIST_NAVIGATION GEN_LIST_NAVIGATION\endlink 
+ * in \link scot/list_nav.h scot/list_nav.h\endlink.
+ *
+ * Normally this is not called directly, but by 
+ * \link scot/list_proto.h::GEN_LIST_PROTO GEN_LIST_PROTO()\endlink 
+ * because this defined just a subset of all function prototypes neccesarry 
+ * to handle typesafe lists.
+ */
+#define  GEN_LIST_NAV_PROTO(type)                                    \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _front          (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _last           (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _next           (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _prev           (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _find           (                                \
+         list_ ## type ## _node_t *,                                 \
+         const type               *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _find_anchor    (                                \
+         list_ ## type ## _node_t *);
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The function prototypes to modify lists of the given 
+ *                   datatype are created.
+ *
+ * \brief Function prototypes for modification.
+ *
+ * This creates the prototypes to the functions that are created by
+ * \link scot/list_mod.h::GEN_LIST_MODIFY GEN_LIST_MODIFY\endlink 
+ * in \link scot/list_mod.h scot/list_mod.h\endlink.
+ *
+ * Normally this is not called directly, but by 
+ * \link scot/list_proto.h::GEN_LIST_PROTO GEN_LIST_PROTO()\endlink 
+ * because this defined just a subset of all function prototypes neccesarry 
+ * to handle typesafe lists.
+ */
+#define  GEN_LIST_MOD_PROTO(type)                                    \
+   STATIC                                                            \
+   type *                                                            \
+   list_ ## type ## _retrive        (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _set            (                                \
+         list_ ## type ## _node_t *,                                 \
+         const type               *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _insert         (                                \
+         list_ ## type ## _node_t *,                                 \
+         const type               *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _delete         (                                \
+         list_ ## type ## _node_t *);                                \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _concat         (                                \
+         list_ ## type ## _node_t *,                                 \
+         list_ ## type ## _node_t *);
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             All function prototypes for a lists of the given 
+ *                   datatype are created.
+ *
+ * \brief Calls GEN_LIST_MAN_PROTO, GEN_LIST_NAV_PROTO and GEN_LIST_MOD_PROTO.
+ *
+ * This creates all the prototypes to the functions that are created by
+ * \link scot/list_impl.h::GEN_LIST_IMPL GEN_LIST_IMPL\endlink in 
+ * \link scot/list_impl.h scot/list_impl.h\endlink.
+ * This provides one with the complete interface to the list of the given
+ * datatype.
+ */
+#define  GEN_LIST_FUNC_PROTO(type)                                   \
+   GEN_LIST_MAN_PROTO   (type);                                      \
+   GEN_LIST_NAV_PROTO   (type);                                      \
+   GEN_LIST_MOD_PROTO   (type);
+
+#endif   /* LIST_FUNC_PROTO_H */

+/**
+ * \file scot/list_impl.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro which creates functions for typesafe lists by templates.
+ *
+ * This combines the macro definitions in \link scot/list_man.h scot/list_man.h
+ * \endlink, \link scot/list_mod.h scot/list_mod.h \endlink and \link
+ * scot/list_nav.h scot/list_nav.h\endlink into one macro that is
+ * normally called within a c file that wants to use lists, as it provides
+ * you with all functions neccesary for list handling.\n
+ * Additionally the whole errorhandling code for lists is here. For that
+ * there are some function prototypes of functions implemented in
+ * \link list.c\endlink here. These functions do error output or will
+ * throw exceptions. Which function is called depends on if 
+ * \link exception.c::USE_NO_EXCEPTIONS USE_NO_EXCEPTIONS\endlink is set at
+ * include time of this file, or not.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_IMPL_H
+#define  LIST_IMPL_H
+
+
+#include <scot/exception.h>
+#include <scot/scot_types.h>
+
+/**
+ * \internal
+ * \param   type     the datatype that this queue code should handle.
+ * \param   a        a variable holding a pointer to queue_[type]_node_t.
+ *
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   a must be a valid pointer to a queue_[type]_node_t.
+ * \returns          \a a cast to a pointer of list_[type]_node_t.
+ * \post             None
+ *
+ * \brief   Cast a pointer to list_[type]_node_t.
+ *
+ * FIXME: I should check better the validity of \a a.
+ */
+#define  LIST(type, a) (list_ ## type ## _node_t *) (a)
+
+void     list_error_print  (const char *, int, int);
+void     list_warning_print  (const char *, int, int);
+void     list_error_throw  (const char *, int, int);
+void     list_warning_throw  (const char *, int, int);
+void *   list_malloc_print (SIZE_T, const char *, int);
+void     list_check_null_print (const void *, const char *, int);
+void *   list_malloc_throw (SIZE_T, const char *, int);
+void     list_check_null_throw (const void *, const char *, int);
+
+#ifdef   USE_NO_EXCEPTION 
+#  define  LIST_ERROR(file, line, id)                                \
+      list_error_print ((file), (line), (id)) 
+#  define  LIST_WARNING(file, line, id)                              \
+      list_warning_print ((file), (line), (id)) 
+#  define  LIST_MALLOC(size, file, line)                             \
+      list_malloc_print ((size), (file), (line)) 
+#  define  LIST_CHECK_NULL(val, file, line)                          \
+      list_check_null_print ((void *) (val), (file), (line)) 
+#  define  LIST_EXC_START 
+#  define  LIST_EXC_END(file, line, id) 
+#else
+/**
+ * \internal
+ * \param   file  filename of the file where the error occured.
+ * \param   line  line in the file where the error occured.
+ * \param   id    list error id.
+ *
+ * \brief print or thow an error
+ */
+#  define  LIST_ERROR(file, line, id)                                \
+      list_error_throw ((file), (line), (id)) 
+/**
+ * \internal
+ * \param   file  filename of the file where the error occured.
+ * \param   line  line in the file where the error occured.
+ * \param   id    list error id.
+ *
+ * \brief print or throw a warning
+ */
+#  define  LIST_WARNING(file, line, id)                              \
+      list_warning_throw ((file), (line), (id)) 
+/**
+ * \internal
+ * \param   size  the amount of memory that should be reserved.
+ * \param   file  filename of the file where this is called.
+ * \param   line  line in the file where this is called.
+ *
+ * \brief list malloc wrapper
+ *
+ * A malloc wrapper which either print an error or throw 
+ * an exception.
+ */
+#  define  LIST_MALLOC(size, file, line)                             \
+      list_malloc_throw ((size), (file), (line)) 
+/**
+ * \internal
+ * \param   val   variable that should be check for NULL.
+ * \param   file  filename of the file where this is called.
+ * \param   line  line in the file where this is called.
+ *
+ * \brief this checks if val is null
+ */
+#  define  LIST_CHECK_NULL(val, file, line)                          \
+      list_check_null_throw ((void *) (val), (file), (line)) 
+/**
+ * \internal
+ * \brief start exception environment in generated list function.
+ */
+#  define  LIST_EXC_START                                            \
+      {                                                              \
+         excenv_t *ee;                                               \
+         TRY {       
+/**
+ * \internal
+ * \brief end the exception environment of the generated list function.
+ *
+ * This ends the exception environment in the generated list
+ * function, that was started with LIST_EXC_START.
+ * Any exception that had occured will be forwarded in the upper
+ * exception environment and if exceptions had occured a new one
+ * will be thrown to the exception environment indicating that the
+ * function fails.
+ */
+#  define  LIST_EXC_END(file, line, id)                              \
+         }                                                           \
+         CATCH (ee)                                                  \
+         {                                                           \
+            forward_all_exceptions (ee);                             \
+            list_error_throw ((file), (line), (id));                 \
+         }                                                           \
+      }
+#endif   /* USE_NO_EXCEPTION */
+
+extern const char *list_err_msg[];
+extern const char *list_wrn_msg[];
+
+struct list_node_t 
+{
+   const char _ [sizeof (struct {
+         const void  *e;
+         const void  *prev;
+         const void  *next;
+         })];
+};
+
+#ifdef   GEN_LOCAL
+/**
+ * \internal
+ * \brief   make functions static or not dependig on if GEN_LOCAL was
+ *          defined or not.
+ */
+#  define   STATIC   static
+#else
+#  define   STATIC
+#endif
+
+#include "list_man.h"
+#include "list_nav.h"
+#include "list_mod.h"
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The functions, struct and globals to handle typesave
+ *                   lists for the given datatype are generated within the
+ *                   calling build file.
+ *                   FIXME: This seems not threadsafe to me, as the globals
+ *                   are used within all threads. Actually one could work
+ *                   around this because normally it is enough to set the
+ *                   comparison functions once and dont touch them anymore
+ *                   but it might be neccesary to compare elements within
+ *                   the list differently in different threads.
+ *
+ * \brief this creates all functions, structs and globals needed for a
+ *        typesafe list of a given \a type.
+ *
+ * In detail the following is created by this macro:\n
+ * \li <b>struct list_[type]_node_t</b>: This is the structure a list
+ * is constructed of. A representation of a double linked list node with
+ * a pointer to the element it contains, a pointer to the next and a pointer
+ * to the previous element in the list. This list implementation uses a kind
+ * of a ringlist, that is the next pointer of the last node in the list
+ * and the prev pointer in the first element of the list points to the anchor.
+ * Thus in an empty list prev and next of the anchor both points to the
+ * anchor.
+ * \li <b>int list_[type]_default_cmp ()</b>: This is the default
+ * comparison function for lists. It simply compares the adresses of two
+ * elements. At list initialization list_[type]_compare() is set to this.
+ * \li <b>list_[type]_cmp_fptr list_[type]_compare</b>: This pointer
+ * to a function that compares list elements is used within the generated
+ * list functions.
+ * \li <b>list_[type]_elem_free_fptr list_[type]_elem_free</b>: This pointer
+ * , if set to non NULL, is used in list_[type]_delete() to free an
+ * element within a node before deleting the node. At initial time of
+ * the list code this is set to NULL, thus elements are not freed at all.
+ * (This is ok when stack variables are used, else one should at least
+ * set list_[type]_elem_free to free().)
+ * \li all functions defined in \link scot/list_man.h list_man.h\endlink,
+ * \link scot/list_mod.h list_mod.h\endlink and 
+ * \link scot/list_nav.h list_nav.h\endlink.
+ */
+#define  GEN_LIST_IMPL(type)                                      \
+struct list_ ## type ## _node_t                                   \
+{                                                                 \
+   const type                       *e;                           \
+   struct list_ ## type ## _node_t  *prev;                        \
+   struct list_ ## type ## _node_t  *next;                        \
+};                                                                \
+                                                                  \
+STATIC                                                            \
+int list_ ## type ## _default_cmp (                               \
+      const type * a,                                             \
+      const type * b)                                             \
+{                                                                 \
+   return (a==b)?0:(a<b)?-1:1;                                    \
+}                                                                 \
+                                                                  \
+STATIC                                                            \
+list_ ## type ## _cmp_fptr                                        \
+list_ ## type ## _compare = list_ ## type ## _default_cmp;        \
+STATIC                                                            \
+list_ ## type ## _elem_free_fptr                                  \
+list_ ## type ## _elem_free = NULL;                               \
+                                                                  \
+GEN_LIST_MANAGEMENT  (type);                                      \
+GEN_LIST_NAVIGATION  (type);                                      \
+GEN_LIST_MODIFY      (type);
+
+#endif   /* LIST_IMPL_H */

+/**
+ * \file scot/list_man.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Templates of functions to manage typesafe lists.
+ *
+ * Here are macro definitions that create functions to manage typesafe
+ * lists. That is create new list, free list, check nodes a.s.f
+ *
+ * Normally the macros defined here will be never called directly but only
+ * via MACROS that group them in a sensefull way in scot/list_impl.h.\n
+ * \anchor onlyfunc_man
+ * \attention
+ * All documentation here does document the functions that are created by
+ * the macros, as the macros themself are pretty easy and all used the same.
+ * They are called with a type, that MUST be one word (use typedef if needed)
+ * and generates the function defined with their value.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_MAN_H
+#define  LIST_MAN_H
+
+#include <stdlib.h>
+#include <scot/list_impl.h>
+#include <scot/memory.h>			/* because we use functions from there */
+
+
+/**
+ * \internal
+ * \param   node     a list_[type]_node_t* that should be checked for
+ *                   beeing an anchor.
+ * \param   line     the line where this MACRO is called.
+ * \pre              a variable of type list_[type]_node_t* must exist.
+ * \return           the code fragment
+ * \post             None
+ *
+ * \brief check for anchor.
+ *
+ * This checks if the given \a node is an anchor. If not it calls
+ * LIST_ERROR, which either raises an exception if exceptions are user
+ * or otherwise prints out an error message to stderr and aborts the 
+ * program.
+ */
+#define  MAN_NODE_NO_ANCHOR_ERROR(node, line)                        \
+      if ((node->e) != NULL)                                         \
+         LIST_ERROR ("list_man.h", (line), NODE_NO_ANCHOR_ERR);
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              None
+ * \return           NULL on error, but only if no exceptions are used.
+ *                   If exceptions are used an exception is thrown on error.
+ *                   On success a pointer to the newly created list_anchor
+ *                   will be returned.
+ * \retval  NULL     if an error occurs and no exceptions are used.
+ * \retval  !=NULL   the pointer to the newly created list anchor.
+ * \post             enough memory on the heap.
+ *
+ * \brief template for list constructor.
+ *
+ * The function creates a new list anchor on the heap and returns it.
+ * This can be used with following list_[type]_*() functions.
+ * The memory reserved for this anchor must be freed by the context
+ * that uses this function if it did not need the list anymore.\n\n
+ */
+#define  GEN_LIST_NEW(type)                                          \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _new (list_ ## type ## _node_t *anchor)          \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         anchor = (list_ ## type ## _node_t *)                       \
+            LIST_MALLOC (sizeof (list_ ## type ## _node_t),          \
+                  "list_man.h", 93);                                 \
+                                                                     \
+         anchor->e      = NULL;                                      \
+         anchor->prev   = anchor;                                    \
+         anchor->next   = anchor;                                    \
+      }                                                              \
+      LIST_EXC_END ("list_man.h", 99, LIST_NEW_ERR);                 \
+                                                                     \
+      return anchor;                                                 \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \pre              anchor must point to a valid list anchor previously
+ *                   assigned by list_[type]_new().
+ * \return           Nothing
+ * \post             The list is completely removed from the heap.
+ *
+ * \brief template for list destructor.
+ *
+ * The function frees a list given by its anchor. It uses list_[type]_delete()
+ * to delete every node one by one and finally it calls free on the anchor.
+ * list_[type]_delete does by default only delete the node and not the
+ * stored element. Read here to learn more.
+ */
+#define  GEN_LIST_FREE(type)                                         \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _free (list_ ## type ## _node_t *anchor)         \
+   {                                                                 \
+      list_ ## type ## _node_t   *next;                              \
+                                                                     \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (anchor, "list_man.h", 48);                 \
+         MAN_NODE_NO_ANCHOR_ERROR (anchor, 49);                      \
+                                                                     \
+         next = list_ ## type ## _next (anchor);                     \
+         while (anchor != next)                                      \
+            next = list_ ## type ## _delete (next);                  \
+                                                                     \
+         SCOT_MEM_FREE (anchor);                                          \
+      }                                                              \
+      LIST_EXC_END ("list_man.h", 58, LIST_FREE_ERR);                \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \param   e        A pointer to a variable of the \a type, the
+ *                   list was created for.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor.\a e must not be NULL.
+ * \return           The node that contains \a e.
+ * \post             None
+ *
+ * \brief Find the node in the list that contains \a e.
+ */
+#define  GEN_LIST_COUNT(type)                                        \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _count (list_ ## type ## _node_t * anchor)       \
+   {                                                                 \
+      int ret = 0;                                                   \
+                                                                     \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         list_ ## type ## _node_t *node;                             \
+                                                                     \
+         LIST_CHECK_NULL (anchor, "list_nav.h", 170);                \
+         NAV_NODE_NO_ANCHOR_ERROR (anchor, 171);                     \
+                                                                     \
+         node = anchor;                                              \
+         while (! list_ ## type ## _eol (anchor, node))              \
+         {                                                           \
+            node = node->next;                                       \
+                                                                     \
+            if (node->e != NULL)                                     \
+               ret ++;                                               \
+         }                                                           \
+      }                                                              \
+      LIST_EXC_END ("list_man.h", 182, LIST_COUNT_ERR);              \
+                                                                     \
+      return ret;                                                    \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \param   node     A pointer to a node in the list.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor, the node has to be not NULL too.
+ * \return           A boolean indicating if the first non-anchor
+ *                   node in the list is node. Tested by the address
+ *                   of the node, so it really must be the same
+ *                   address.
+ * \retval  TRUE     The node is the first node in the list.
+ * \retval  FALSE    The node is not the first node in the list.
+ * \post             None
+ *
+ * \brief Checks if node is at the beginning of the list.
+ */
+#define  GEN_LIST_BOL(type)                                          \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _bol (                                           \
+         list_ ## type ## _node_t   *anchor,                         \
+         list_ ## type ## _node_t   *node)                           \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (anchor, "list_man.h", 70);                 \
+         LIST_CHECK_NULL (node, "list_man.h", 71);                   \
+         MAN_NODE_NO_ANCHOR_ERROR (anchor, 72);                      \
+      }                                                              \
+      LIST_EXC_END ("list_man.h", 74, LIST_BOL_ERR);                 \
+                                                                     \
+      return anchor->next==node;                                     \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \param   node     A pointer to a node in the list.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor, the node has to be not NULL too.
+ * \return           A boolean indicating if the last non-anchor
+ *                   node in the list is node. Tested by the address
+ *                   of the node, so it really must be the same
+ *                   address.
+ * \retval  TRUE     The node is the last node in the list.
+ * \retval  FALSE    The node is not the last node in the list.
+ * \post             None
+ *
+ * \brief Checks if node is at the end of the list.
+ */
+#define  GEN_LIST_EOL(type)                                          \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _eol (                                           \
+         list_ ## type ## _node_t   *anchor,                         \
+         list_ ## type ## _node_t   *node)                           \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (anchor, "list_man.h", 88);                 \
+         LIST_CHECK_NULL (node, "list_man.h", 89);                   \
+         MAN_NODE_NO_ANCHOR_ERROR (anchor, 90);                      \
+      }                                                              \
+      LIST_EXC_END ("list_man.h", 92, LIST_EOL_ERR);                 \
+                                                                     \
+		if (list_ ## type ## _isempty (anchor)) return -1;             \
+      return node->next==anchor;                                     \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor.
+ * \return           A boolean indicating if the last non-anchor
+ *                   node in the list is node. Tested by the address
+ *                   of the node, so it really must be the same
+ *                   address.
+ * \retval  TRUE     The node is the last node in the list.
+ * \retval  FALSE    The node is not the last node in the list.
+ * \post             None
+ *
+ * \brief Checks if node is at the end of the list.
+ */
+#define  GEN_LIST_ISEMPTY(type)                                      \
+   STATIC                                                            \
+   int                                                               \
+   list_ ## type ## _isempty (list_ ## type ## _node_t *anchor)      \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+         LIST_CHECK_NULL (anchor, "list_man.h", 103);                \
+      LIST_EXC_END ("list_man.h", 104, LIST_ISEMPTY_ERR);            \
+                                                                     \
+      return (anchor->prev==anchor && anchor->next==anchor);         \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   cmp      A pointer to a function that compares two
+ *                   variables of \a type.
+ * \pre              None
+ * \return           Nothing
+ * \post             None
+ *
+ * \brief Set the compare function to \a cmp.
+ *
+ * This sets the compare function used by some functions generated
+ * for a list of the \a type datatype. This compare function has
+ * to work similar to strcmp. It should return either <0, ==0 or >0
+ * depending on what comparator is lesser, greater or equal.
+ */
+#define  GEN_LIST_SET_CMP(type)                                      \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _set_cmp (list_ ## type ## _cmp_fptr cmp)        \
+   {                                                                 \
+      list_ ## type ## _compare = cmp;                               \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   cmp      A pointer to a function that compares two
+ *                   variables of \a type.
+ * \pre              None
+ * \return           Nothing
+ * \post             None
+ *
+ * \brief Set the compare function to \a cmp.
+ *
+ * This sets the compare function used by some functions generated
+ * for a list of the \a type datatype. This compare function has
+ * to work similar to strcmp. It should return either <0, ==0 or >0
+ * depending on what comparator is lesser, greater or equal.
+ */
+#define  GEN_LIST_SET_ELEM_FREE(type)                                \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _set_elem_free (                                 \
+         list_ ## type ## _elem_free_fptr efree)                     \
+   {                                                                 \
+      list_ ## type ## _elem_free = efree;                           \
+   }
+
+
+
+#define  GEN_LIST_ELEM_FREE_IS_SET(type)                             \
+   STATIC                                                            \
+   long                                                               \
+   list_ ## type ## _elem_free_is_set (void)                         \
+   {                                                                 \
+      return (long) list_ ## type ## _elem_free;                      \
+   }
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The functions for the given datatype that are described
+ *                   here are generated within the calling build file.
+ *
+ * \brief create functions neccesary to manage lists of the given \a type.
+ *
+ * Normally this is not called directly, but by GEN_LIST_IMPL() because this
+ * defined just a subset of all functions neccesarry to handle typesafe lists.
+ */
+#define  GEN_LIST_MANAGEMENT(type)                                   \
+   GEN_LIST_SET_CMP        (type);                                   \
+   GEN_LIST_SET_ELEM_FREE  (type);                                   \
+   GEN_LIST_ELEM_FREE_IS_SET (type)                                  \
+   GEN_LIST_NEW            (type);                                   \
+   GEN_LIST_FREE           (type);                                   \
+   GEN_LIST_COUNT          (type);                                   \
+   GEN_LIST_BOL            (type);                                   \
+   GEN_LIST_ISEMPTY        (type);                                   \
+   GEN_LIST_EOL            (type);
+
+
+#endif   /* LIST_MAN_H */

+/**
+ * \file scot/list_mod.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Templates of functions to modify typesafe lists.
+ *
+ * Here are macro definitions that create functions to modify typesafe
+ * lists. That is read, write, insert, delete a.s.f.
+ *
+ * Normally the macros defined here will be never called directly but only
+ * via MACROS that group them in a sensefull way in scot/list_impl.h.\n
+ * \anchor onlyfunc_mod
+ * \attention
+ * All documentation here does document the functions that are created by
+ * the macros, as the macros themself are pretty easy and all used the same.
+ * They are called with a type, that MUST be one word (use typedef if needed)
+ * and generates the function defined with their value.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_MOD_H
+#define  LIST_MOD_H
+
+#include <stdlib.h>
+#include <scot/list_impl.h>
+#include <scot/memory.h>			/* because we use functions from there */
+
+
+/**
+ * \internal
+ * \param   node     a list_[type]_node_t* that should be checked for
+ *                   beeing an anchor.
+ * \param   line     the line where this MACRO is called.
+ * \pre              a variable of type list_<type>_node_t* must exist.
+ * \return           the code fragment
+ * \post             None
+ *
+ * \brief check for anchor.
+ *
+ * This checks if the given \a node is an anchor. If not it calls
+ * LIST_ERROR, which either raises an exception if exceptions are user
+ * or otherwise prints out an error message to stderr and aborts the 
+ * program.
+ */
+#define  MOD_NODE_NO_ANCHOR_ERROR(node, line)                        \
+      if ((node->e) != NULL)                                         \
+         LIST_ERROR ("list_mod.h", (line), NODE_NO_ANCHOR_ERR);
+
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_mod "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \pre              The \a node must be part of a correctly 
+ *                   initialized list.
+ * \return           The element saved in the node.
+ * \post             None
+ *
+ * \brief Retrive element from node.
+ *
+ * This function retrieves the element from a node of a list.
+ */
+#define  GEN_LIST_RETRIVE(type)                                      \
+   STATIC                                                            \
+   type *                                                            \
+   list_ ## type ## _retrive (list_ ## type ## _node_t *node)        \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+         LIST_CHECK_NULL (node, "list_mod.h", 18);                   \
+      LIST_EXC_END ("list_mod.h", 19, LIST_RETR_ERR);                \
+                                                                     \
+      return (type *) node->e;                                       \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_mod "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \param   e        A pointer to a variable of the \a type, the
+ *                   list was created for.
+ * \pre              The \a node must be part of a correctly 
+ *                   initialized list. \a e must not be NULL.
+ * \return           Nothing
+ * \post             The element of \a node is \a e.
+ *
+ * \brief Set element od node.
+ *
+ * This function sets the element from a node of a list.
+ */
+#define  GEN_LIST_SET(type)                                          \
+   STATIC                                                            \
+   void                                                              \
+   list_ ## type ## _set (                                           \
+         list_ ## type ## _node_t   *node,                           \
+         const type                 *e)                              \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (node, "list_mod.h", 33);                   \
+         LIST_CHECK_NULL (e, "list_mod.h", 34);                      \
+      }                                                              \
+      LIST_EXC_END ("list_mod.h", 36, LIST_SET_ERR);                 \
+                                                                     \
+      node->e = e;                                                   \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_mod "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \param   e        A pointer to a variable of the \a type, the
+ *                   list was created for.
+ * \pre              The \a node must be part of a correctly 
+ *                   initialized list.
+ *                   \a e must not be NULL.
+ * \return           The node of the inserted element.
+ * \post             List has one new node containing \a e.
+ *
+ * \brief Inserts a new node with element \a e into the list.
+ * 
+ * This function creates a new list node and initializes it with
+ * \a e. Then this new node will be inserted behind \a node.
+ */
+#define  GEN_LIST_INSERT(type)                                       \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _insert (                                        \
+         list_ ## type ## _node_t   *node,                           \
+         const type                 *e)                              \
+   {                                                                 \
+      list_ ## type ## _node_t   *ret;                               \
+                                                                     \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         list_ ## type ## _node_t   *new_node;                       \
+                                                                     \
+         LIST_CHECK_NULL (node, "list_mod.h", 54);                   \
+         LIST_CHECK_NULL (e, "list_mod.h", 55);                      \
+                                                                     \
+         new_node = (list_ ## type ## _node_t *)                     \
+            LIST_MALLOC (sizeof (list_ ## type ## _node_t),          \
+                  "list_mod.h", 58);                                 \
+                                                                     \
+         new_node->e       = e;                                      \
+         new_node->prev    = node;                                   \
+         new_node->next    = node->next;                             \
+         node->next->prev  = new_node;                               \
+         node->next        = new_node;                               \
+                                                                     \
+         ret = new_node;                                             \
+      }                                                              \
+      LIST_EXC_END ("list_mod.h", 69, LIST_INSERT_ERR);              \
+                                                                     \
+      return ret;                                                    \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_mod "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \pre              The \a node must be part of a correctly 
+ *                   initialized list.
+ * \return           The next node behind the deleted one.
+ * \post             The \a node is removed from the list and
+ *                   freed.
+ *
+ * \brief Deletes a new node with element \a e into the list.
+ * 
+ * This function deletes a node from the list it is in. The node
+ * will be freed but by default NOT the element. Anyway, one can set
+ * a free function for elements of the list. This should free any
+ * resource the element has reserved.
+ * This function can be set with 
+ * \link list_man.h::GEN_LIST_SET_ELEM_FREE 
+ * list_[type]_set_elem_free ()\endlink
+ * and if set, is called by list_[type]_delete(). If such a function
+ * was set and one wants to reset to default behaviour (not to delete any
+ * element) one can pass NULL to \link list_man.h::GEN_LIST_SET_ELEM_FREE
+ * list_[type]_set_elem_free ()\endlink.
+ */
+#define  GEN_LIST_DELETE(type)                                       \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _delete (list_ ## type ## _node_t  *node)        \
+   {                                                                 \
+      type                       *e;                                 \
+      list_ ## type ## _node_t   *prev,                              \
+                                 *next;                              \
+                                                                     \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         if (list_ ## type ## _isempty (node))                       \
+            LIST_WARNING ("list_mod.h", 86, DEL_ON_EMPTY_LIST_WRN);  \
+                                                                     \
+         e = (type *) node->e;                                       \
+                                                                     \
+         prev        = node->prev;                                   \
+         next        = node->next;                                   \
+         prev->next  = next;                                         \
+         next->prev  = prev;                                         \
+                                                                     \
+         if (list_ ## type ## _elem_free != NULL && e != NULL)       \
+            list_ ## type ## _elem_free (e);                         \
+                                                                     \
+         SCOT_MEM_FREE (node);                                       \
+      }                                                              \
+      LIST_EXC_END ("list_mod.h", 101, LIST_DELETE_ERR);             \
+                                                                     \
+      return next;                                                   \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_mod "here".
+ *
+ * \param   anchor1  A pointer to the first list anchor.
+ * \param   anchor2  A pointer to the second list anchor.
+ * \pre              Both, \a anchor1 and \a anchor2 must be
+ *                   valid list_anchors.
+ * \return           The anchor of the new concatenated list.
+ * \post             A new list was created that contains both
+ *                   given lists. The anchor of at least one of the
+ *                   given lists is no longer valid and should no
+ *                   longer be used. In fact only the returned
+ *                   anchor is garantied to point to a valid list.
+ *
+ * \brief Concatenates two lists.
+ * 
+ * This function joins the given two list to one. This will be done
+ * partly destructive...that is, at least one of the old anchors
+ * will be deleted.
+ */
+#define  GEN_LIST_CONCAT(type)                                       \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _concat (                                        \
+         list_ ## type ## _node_t   *anchor1,                        \
+         list_ ## type ## _node_t   *anchor2)                        \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (anchor1, "list_mod.h", 115);               \
+         MOD_NODE_NO_ANCHOR_ERROR (anchor1, 116);                    \
+         LIST_CHECK_NULL (anchor2, "list_mod.h", 117);               \
+         MOD_NODE_NO_ANCHOR_ERROR (anchor2, 118);                    \
+      }                                                              \
+      LIST_EXC_END ("list_mod.h", 120, LIST_CONCAT_ERR);             \
+                                                                     \
+      if (list_ ## type ## _isempty (anchor1))                       \
+         return anchor2;                                             \
+                                                                     \
+      if (list_ ## type ## _isempty (anchor2))                       \
+         return anchor1;                                             \
+                                                                     \
+      anchor2->next->prev  = anchor1->prev;                          \
+      anchor2->prev->next  = anchor1;                                \
+      anchor1->prev->next  = anchor2->next;                          \
+      anchor1->prev        = anchor2->prev;                          \
+   }
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The functions for the given datatype that are described
+ *                   here are generated within the calling build file.
+ *
+ * \brief create functions neccesary to modify lists of the given \a type.
+ *
+ * Normally this is not called directly, but by GEN_LIST_IMPL() because this
+ * defines just a subset of all functions neccesarry to handle typesafe lists.
+ */
+#define  GEN_LIST_MODIFY(type)                                       \
+   GEN_LIST_RETRIVE     (type);                                      \
+   GEN_LIST_SET         (type);                                      \
+   GEN_LIST_INSERT      (type);                                      \
+   GEN_LIST_DELETE      (type);                                      \
+   GEN_LIST_CONCAT      (type);
+
+
+
+#endif   /* LIST_MOD_H */

+/**
+ * \file scot/list_nav.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Templates of functions to navigate within typesafe lists.
+ *
+ * Here are macro definitions that create functions to navigate within
+ * typesafe lists. That is get next node, get first node a.s.f
+ *
+ * Normally the macros defined here will be never called directly but only
+ * via MACROS that group them in a sensefull way in scot/list_impl.h.\n
+ * \anchor onlyfunc_nav
+ * \attention
+ * All documentation here does document the functions that are created by
+ * the macros, as the macros themself are pretty easy and all used the same.
+ * They are called with a type, that MUST be one word (use typedef if needed)
+ * and generates the function defined with their value.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_NAV_H
+#define  LIST_NAV_H
+
+#include <stdlib.h>
+#include <scot/list_impl.h>
+
+
+
+/**
+ * \internal
+ * \param   node     a list_[type]_node_t* that should be checked for
+ *                   beeing an anchor.
+ * \param   line     the line where this MACRO is called.
+ * \pre              a variable of type list_[type]_node_t* must exist.
+ * \return           the code fragment
+ * \post             None
+ *
+ * \brief check for anchor.
+ *
+ * This checks if the given \a node is an anchor. If not it calls
+ * LIST_ERROR, which either raises an exception if exceptions are user
+ * or otherwise prints out an error message to stderr and aborts the 
+ * program.
+ */
+#define  NAV_NODE_NO_ANCHOR_ERROR(node, line)                        \
+      if ((node->e) != NULL)                                         \
+         LIST_ERROR ("list_nav.h", (line), NODE_NO_ANCHOR_ERR);
+
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor.
+ * \return           The first node in the list, that is normally
+ *                   the anchor, thus this is pretty useless.
+ * \post             None
+ *
+ * \brief Returns the first element in the list, that is the anchor...
+ *        pathetic...
+ */
+#define  GEN_LIST_FRONT(type)                                        \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _front (list_ ## type ## _node_t  *anchor)       \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (anchor, "list_nav.h", 20);                 \
+         NAV_NODE_NO_ANCHOR_ERROR (anchor, 21);                      \
+      }                                                              \
+      LIST_EXC_END ("list_nav.h", 23, LIST_FRONT_ERR);               \
+                                                                     \
+      return anchor;                                                 \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor.
+ * \return           The last node in the list.
+ * \post             None
+ *
+ * \brief Get the last node in the list.
+ */
+#define  GEN_LIST_LAST(type)                                         \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _last (list_ ## type ## _node_t  *anchor)        \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         LIST_CHECK_NULL (anchor, "list_nav.h", 35);                 \
+         NAV_NODE_NO_ANCHOR_ERROR (anchor, 36);                      \
+      }                                                              \
+      LIST_EXC_END ("list_nav.h", 38, LIST_LAST_ERR);                \
+                                                                     \
+      return anchor->prev;                                           \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \pre              The node has to be not NULL and should be in
+ *                   a linked list.
+ * \return           The next node after the given node.
+ * \post             None
+ *
+ * \brief Get the next node in the list.
+ */
+#define  GEN_LIST_NEXT(type)                                         \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _next (list_ ## type ## _node_t  *node)          \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+         LIST_CHECK_NULL (node, "list_nav.h", 49);                   \
+      LIST_EXC_END ("list_nav.h", 50, LIST_NEXT_ERR);                \
+                                                                     \
+      return node->next;                                             \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \pre              The node has to be not NULL and should be in
+ *                   a linked list.
+ * \return           The previous node after the given node.
+ * \post             None
+ *
+ * \brief Get the previous node in the list.
+ */
+#define  GEN_LIST_PREV(type)                                         \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _prev (list_ ## type ## _node_t  *node)          \
+   {                                                                 \
+      LIST_EXC_START                                                 \
+         LIST_CHECK_NULL (node, "list_nav.h", 61);                   \
+      LIST_EXC_END ("list_nav.h", 62, LIST_PREV_ERR);                \
+                                                                     \
+      return node->prev;                                             \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   anchor   A pointer to the list anchor.
+ * \param   e        A pointer to a variable of the \a type, the
+ *                   list was created for.
+ * \pre              The \a anchor has to be not NULL and a valid
+ *                   anchor.\a e must not be NULL.
+ * \return           The node that contains \a e.
+ * \post             None
+ *
+ * \brief Find the node in the list that contains \a e.
+ */
+#define  GEN_LIST_FIND(type)                                         \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _find (                                          \
+         list_ ## type ## _node_t   *anchor,                         \
+         const type                 *e)                              \
+   {                                                                 \
+      list_ ## type ## _node_t *ret = NULL;                          \
+                                                                     \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         list_ ## type ## _node_t *node;                             \
+                                                                     \
+         LIST_CHECK_NULL (anchor, "list_nav.h", 80);                 \
+         NAV_NODE_NO_ANCHOR_ERROR (anchor, 81);                      \
+                                                                     \
+         node = anchor;                                              \
+         while (! list_ ## type ## _eol (anchor, node))              \
+         {                                                           \
+            node = node->next;                                       \
+                                                                     \
+            if (node->e != NULL)                                     \
+               if (list_ ## type ## _compare (e, node->e) == 0)      \
+                  ret = node;                                        \
+         }                                                           \
+      }                                                              \
+      LIST_EXC_END ("list_nav.h", 93, LIST_FIND_ERR);                \
+                                                                     \
+      return ret;                                                    \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_man "here".
+ *
+ * \param   node     A pointer to a node in the list.
+ * \pre              The node has to be not NULL and should be in
+ *                   a linked list.
+ * \return           The anchor of the list, the \a node is in.
+ * \post             None
+ *
+ * \brief Get the anchor of the list.
+ */
+#define  GEN_LIST_FIND_ANCHOR(type)                                  \
+   STATIC                                                            \
+   list_ ## type ## _node_t *                                        \
+   list_ ## type ## _find_anchor (                                   \
+         list_ ## type ## _node_t   *entry)                          \
+   {                                                                 \
+      list_ ## type ## _node_t *ret = NULL;                          \
+                                                                     \
+      LIST_EXC_START                                                 \
+      {                                                              \
+         list_ ## type ## _node_t *node;                             \
+                                                                     \
+         LIST_CHECK_NULL (entry, "list_nav.h", 110);                 \
+                                                                     \
+         node = entry;                                               \
+         if (node->e == NULL)                                        \
+            ret = node;                                              \
+                                                                     \
+         while (! list_ ## type ## _eol (entry, node))               \
+         {                                                           \
+            node = node->next;                                       \
+                                                                     \
+            if (node->e == NULL)                                     \
+               ret = node;                                           \
+         }                                                           \
+                                                                     \
+         if (ret == NULL)                                            \
+            LIST_ERROR ("list_nav.h", 125, MALFORMED_LIST_ERR);      \
+      }                                                              \
+      LIST_EXC_END ("list_nav.h", 127, LIST_FIND_ANCHOR_ERR);        \
+                                                                     \
+      return NULL;                                                   \
+   }
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The functions for the given datatype that are described
+ *                   here are generated within the calling build file.
+ *
+ * \brief create functions neccesary to modify lists of the given \a type.
+ *
+ * Normally this is not called directly, but by GEN_LIST_IMPL() because this
+ * defines just a subset of all functions neccesarry to handle typesafe lists.
+ */
+#define  GEN_LIST_NAVIGATION(type)                                   \
+   GEN_LIST_FRONT       (type);                                      \
+   GEN_LIST_LAST        (type);                                      \
+   GEN_LIST_NEXT        (type);                                      \
+   GEN_LIST_PREV        (type);                                      \
+   GEN_LIST_FIND        (type);                                      \
+   GEN_LIST_FIND_ANCHOR (type);
+
+
+
+#endif   /* LIST_NAV_H */

+/**
+ * \file scot/list_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   This generates all prototypes needed for typesafe lists.
+ *
+ * This combines the macro definitions in \link scot/list_type_proto.h 
+ * scot/list_type_proto.h \endlink and \link scot/list_func_proto.h 
+ * scot/list_func_proto.h \endlink.
+ * Additionally defines for all errornumbers that list will create can be
+ * found here.
+ * GEN_LIST_PROTO is normally called in a header file that describes a 
+ * new Datatype and also wants lists of it.
+ * By doing this the complete interface to lists of that datatype is
+ * produced.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_PROTO_H
+#define  LIST_PROTO_H
+
+#include <scot/list_type_proto.h>
+#include <scot/list_func_proto.h>
+
+/** \brief errnum if list_[type]_new() failes*/
+#define  LIST_NEW_ERR            0x00 
+/** \brief errnum if list_[type]_free() failes*/
+#define  LIST_FREE_ERR           0x01 
+/** \brief errnum if list_[type]_bol() failes*/
+#define  LIST_BOL_ERR            0x02 
+/** \brief errnum if list_[type]_eol() failes*/
+#define  LIST_EOL_ERR            0x03 
+/** \brief errnum if list_[type]_isempty() failes*/
+#define  LIST_ISEMPTY_ERR        0x04 
+/** \brief errnum if list_[type]_front() failes*/
+#define  LIST_FRONT_ERR          0x05 
+/** \brief errnum if list_[type]_last() failes*/
+#define  LIST_LAST_ERR           0x06 
+/** \brief errnum if list_[type]_next() failes*/
+#define  LIST_NEXT_ERR           0x07 
+/** \brief errnum if list_[type]_prev() failes*/
+#define  LIST_PREV_ERR           0x08 
+/** \brief errnum if list_[type]_find() failes*/
+#define  LIST_FIND_ERR           0x09 
+/** \brief errnum if list_[type]_find_anchor() failes*/
+#define  LIST_FIND_ANCHOR_ERR    0x0A 
+/** \brief errnum if list_[type]_retrive() failes*/
+#define  LIST_RETR_ERR           0x0B 
+/** \brief errnum if list_[type]_set() failes*/
+#define  LIST_SET_ERR            0x0C 
+/** \brief errnum if list_[type]_insert() failes*/
+#define  LIST_INSERT_ERR         0x0D 
+/** \brief errnum if list_[type]_delete() failes*/
+#define  LIST_DELETE_ERR         0x0E 
+/** \brief errnum if list_[type]_concat() failes*/
+#define  LIST_CONCAT_ERR         0x0F 
+/** \brief errnum if list_[type]_count() failes*/
+#define  LIST_COUNT_ERR          0x10 
+
+/** \brief errnum if node is no anchor*/
+#define  NODE_NO_ANCHOR_ERR      0x11 
+/** \brief errnum if list has no anchor*/
+#define  MALFORMED_LIST_ERR      0x12 
+
+/** \brief warning if delete on empty list*/
+#define  DEL_ON_EMPTY_LIST_WRN   0x01 
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The typedefs, struct declaration and function prototypes
+ *                   for functions to lists for the given datatype are 
+ *                   generated within the calling build file.
+ *
+ * \brief this creates all typdefs, declarations and prototypes needed for a
+ *        typesafe list of a given \a type. This is normally calles within
+ *        a header file.
+ */
+#define  GEN_LIST_PROTO(type)                         \
+   GEN_LIST_TYPE_PROTO (type)                         \
+   GEN_LIST_FUNC_PROTO (type)
+
+#endif   /* LIST_PROTO_H */

+/**
+ * \file scot/list_type_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro that creates the datatype for handling linked lists.
+ *
+ * The macros here create all datatype prototypes typedefs declarations to 
+ * the implementations created by the macros in 
+ * \link scot/list_impl.h scot/list_impl.h\endlink.
+ * These macros are normally not called directly within your code but
+ * through \link scot/list_proto.h::GEN_LIST_PROTO GEN_LIST_PROTO\endlink. 
+ * This is because normally one did not only
+ * want the datatypes but also the interface declaration to them.
+ * 
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  LIST_TYPE_PROTO_H
+#define  LIST_TYPE_PROTO_H
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ * \return           Nothing
+ * \post             The datatype prototypes for lists of the given 
+ *                   datatype are created.
+ *
+ * \brief Datatype prototypes to lists.
+ *
+ * This creates the prototypes of the datatypes needed to use the
+ * list interface.
+ *
+ * Normally this is not called directly, but by 
+ * \link scot/list_proto.h::GEN_LIST_PROTO GEN_LIST_PROTO()\endlink 
+ * because it is also neccesary to create the interface to this 
+ * datatypes for working lists.
+ */
+#define  GEN_LIST_TYPE_PROTO(type)                                   \
+   struct list_ ## type ## _node_t;                                  \
+   typedef struct list_ ## type ## _node_t                           \
+      list_ ## type ## _node_t;                                      \
+                                                                     \
+   typedef int (*list_ ## type ## _cmp_fptr) (                       \
+         const type *,                                               \
+         const type *);                                              \
+                                                                     \
+   typedef void (*list_ ## type ## _elem_free_fptr) (type *);
+
+#endif   /* LIST_TYPE_PROTO_H */

+/*
+ * dir.h: as one might suggest here are definitions and prototypes for
+ *        posix/dir.c
+ *
+ * Copyright (C) 2006 Georg Steffers
+ *
+ * Author:    Georg Steffers [GST] <georg.steffers@aschendorff.de>
+ * Developer:
+ *
+ * Changes (for this file only):
+ *   (2006-06-12) [GST] Started this changelog...well the program is
+ *                      ready since some weeks right now.
+ */
+#ifndef DIR_H
+#define DIR_H
+
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include <scot/dir_common.h>
+#include <scot/event_listener.h>
+
+struct scot_dir
+{
+	struct scot_event_listener el;
+
+	DIR *                      handle;
+	const char *               path;
+
+	int                        notify_handle;
+};
+
+/* abstraction for file information and an directory handle */
+#define FILE_DATA       struct dirent_stat
+#define DIR_HANDLE      DIR *
+/* #define DIR_HANDLE      struct scot_dir * */
+
+/* abstraction for checking if a file is a directory */
+#define IS_DIRECTORY(file_data) (S_ISDIR ((file_data).stat.st_mode))
+
+/* abstraction for getting the filename of a directory entry. */
+#define DIRENT_FNAME(file_data) ((file_data).file->d_name)
+
+/* !!!FIXME!!! is there any place where this is already defined in posix? */
+#ifndef MAX_PATH
+#  define MAX_PATH   2000
+#endif /* MAX_PATH */
+
+/* structure for all available information about the directory entry. */
+struct dirent_stat
+{
+	char                       path [MAX_PATH+1];
+	struct dirent *            file;
+	struct stat                stat;
+};
+
+
+/* the last parameter is posix specific. It defines if stat should
+ * follow symlinks or not. Under Windows it is ignored. */
+DIR_HANDLE get_dir_first (const char *, FILE_DATA *, int);
+int        get_dir_next  (DIR_HANDLE, const char *, FILE_DATA *, int);
+
+/*
+DIR_HANDLE scot_dir_new  (const char *);
+void       scot_dir_free (DIR_HANDLE);
+
+int get_dir_first (DIR_HANDLE, FILE_DATA *, int);
+int get_dir_next  (DIR_HANDLE, FILE_DATA *, int);
+*/
+
+#endif /* DIR_H */

+/***************************************************************************
+ * memory.h: Prototypes for default memory operations like memcpy and thus *
+ *           on a win32 system nearly all CRT functions (CRT is the        *
+ *           windows C RunTime, that is the normal libC) aren't thread-    *
+ *           safe. As i build up tests this causes problems for example    *
+ *           with strcpy. So i decided to write wrapper that use non CRT   *
+ *           functions on Windows and normal libC ones on a posix system.  *
+ *                                                                         *
+ * Author:   Georg Steffers <georg@steffers.org>                           *
+ * Date:     03/06/2006                                                    *
+ ***************************************************************************/
+#ifndef MEMORY_H
+#define MEMORY_H
+
+#include <string.h>
+#include <sys/types.h>
+
+#include <scot_common.h>
+
+#define SCOT_MEM_GET          malloc
+#define SCOT_MEM_FREE(p)      if ((p)) {free((p)); (p)=NULL;}
+#define SCOT_MEM_COPY         memcpy
+#define SCOT_MEM_MOVE         memmove
+#define SCOT_MEM_FILL         memset
+#define SCOT_MEM_ZERO(p,s)    memset ((p), 0, (s))
+#define SCOT_STR_LENGTH       strlen
+#define SCOT_STR_COPY         strcpy
+#define SCOT_STRN_COPY        strncpy
+#define SCOT_STR_CHAR         strchr
+#define SCOT_STRR_CHAR        strrchr
+
+#endif /* MEMORY_H */

+#ifndef SCOT_TYPES_H
+#define SCOT_TYPES_H
+
+#include <sys/types.h>
+
+typedef ssize_t SSIZE_T;
+typedef size_t  SIZE_T;
+
+#endif /* SCOT_TYPES_H */

+/*
+ * used for threadsafety within exception
+ * actually only pthread is supported
+ */
+#ifndef  THREAD_H
+#define  THREAD_H
+
+#include <stdio.h>
+#include <pthread.h>
+
+#include <scot/scot_int.h>
+
+#ifndef INFINITE
+#  define   INFINITE                   0
+#endif /* INFINITE */
+
+
+#define  JOIN_OK             0x00
+#define  JOIN_TIMEOUT        0x01
+#define  JOIN_ERROR          0x02
+
+/*
+ * i guess it is possible to write mutex code that uses cond
+ * elements to timeout on lock, but right now i have no clear
+ * idea of how to do this. The following thoughts i had:
+ * - create a struct that holds a pthread_mutex_t and a pthread_cond_t
+ *   for every mutex. 
+ * - lock mutexes only by calling pthread_cond_timedwait
+ * And here starts the problem...to do a cond_timedwait i need to ensure
+ * that the mutex is already locked...well and then a question i have not
+ * clearyfied, if a thread ends, will all locks on mutexes be removed?
+ * I guess so, but i did not test it. And an even more important question,
+ * is it possible to write cleanup-code that guarantees that a
+ * pthread_cond_signal is called for every mutex the thread holds...
+ * well, we will end up with the requirement that the programmer has to
+ * call a release mutex function before ending a thread and if the programmer
+ * forgets that the behaviour of out code is unspecified
+ * Right now i will not support timeouts on mutex-locks and to be consistent
+ * it is not supported on win32 either, also it would be much easier to
+ * implement there.
+ */
+#define  MUTEX_LOCK_OK       0x00
+#define  MUTEX_LOCK_ERROR    0x02
+
+#define  THREAD_T                   pthread_t
+#define  THREAD_ID_T                pthread_t
+#define  THREAD_ID                  pthread_self    ()
+#define  SELF_THREAD                pthread_self    ()
+#define  THREAD_EQUAL               pthread_equal
+#define  NEW_THREAD(th,f, a)        thread_new      ((th), (f), (a))
+#define  END_THREAD                 thread_end
+#define  DETACH_THREAD(thread)      pthread_detach  ((thread))
+#define  CANCEL_THREAD(thread)      pthread_cancel  ((thread))
+#define  EXIT_THREAD(retval)        pthread_exit    ((void *) (retval))
+#define  JOIN_THREAD                thread_join                               
+#define  THREAD_CANCEL_ENABLE       pthread_setcancelstate \
+		(PTHREAD_CANCEL_ENABLE, NULL)
+#define  THREAD_CANCEL_DISABLE      pthread_setcancelstate \
+		(PTHREAD_CANCEL_DISABLE, NULL)
+#define  THREAD_CANCEL_ASYNC        pthread_setcanceltype \
+		(PTHREAD_CANCEL_ASYNCHRONOUS, NULL)
+#define  THREAD_CANCEL_DEFER        pthread_setcanceltype \
+		(PTHREAD_CANCEL_DEFERRED, NULL)
+#define  THREAD_TESTCANCEL          pthread_testcancel ()
+#define  T_PROC_RET                 void *
+
+#define  THREAD_MUTEX_T             pthread_mutex_t
+#define  NEW_THREAD_MUTEX           thread_mutex_new
+#define  FREE_THREAD_MUTEX          pthread_mutex_destroy
+#define  LOCK_THREAD_MUTEX          thread_mutex_lock
+#define  UNLOCK_THREAD_MUTEX        pthread_mutex_unlock
+
+#define  THREAD_COND_T                 pthread_cond_t
+#define  THREAD_COND_CS_T              pthread_mutex_t
+#define  GET_THREAD_COND(c)            (*(c) = PTHREAD_COND_INITIALIZER)
+#define  GET_THREAD_COND_CS(c)         (*(c) = PTHREAD_MUTEX_INITIALIZER)
+#define  NEW_THREAD_COND               thread_cond_new
+#define  NEW_THREAD_COND_CS            thread_mutex_new
+#define  FREE_THREAD_COND              pthread_cond_destroy
+#define  FREE_THREAD_COND_CS           pthread_mutex_destroy
+#define  THREAD_COND_ENTER_CS(cs)      pthread_mutex_lock ((cs))
+#define  THREAD_COND_LEAVE_CS(cs)      pthread_mutex_unlock ((cs))
+#define  SIGNAL_THREAD_COND(cond)      pthread_cond_signal ((cond))
+#define  BCAST_THREAD_COND(cond)       pthread_cond_broadcast ((cond))
+#define  WAIT_THREAD_COND(cond, cs, t) thread_cond_wait ((cond), (cs), t)
+
+#define  THREAD_ATEXIT_BEGIN        pthread_cleanup_push
+#define  THREAD_ATEXIT_END          pthread_cleanup_pop
+
+typedef T_PROC_RET (*scot_thread_entry_fptr) (void *);
+
+void           thread_new        (THREAD_T *, T_PROC_RET (*)(void *), void*);
+int            thread_join       (THREAD_T, uint32_t);
+void           thread_end        (THREAD_T, uint32_t);
+void           thread_mutex_new  (THREAD_MUTEX_T *);
+void           thread_cond_new   (THREAD_COND_T *);
+int            thread_mutex_lock (THREAD_MUTEX_T *);
+
+int            thread_cond_wait    (THREAD_COND_T *, 
+                                    THREAD_COND_CS_T *, uint32_t);
+
+#endif   /* THREAD_H */

+/**
+ * \file scot/queue.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro which produce all prototypes and implementations for 
+ *          handling queues based on linked lists by Templates.
+ *
+ * This is the toplevel template file for queues based on typesafe lists. 
+ * It is quite simple. It just defines one MACRO which in turn calls two 
+ * other macros to generate all that is needed for queue-handling of a queue 
+ * to a given type.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  QUEUE_H
+#define  QUEUE_H
+
+#include <scot/queue_proto.h>
+#include <scot/queue_impl.h>
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST(type) has to be called for the list functions,
+ *                   as queues depend on these.
+ * \return           Nothing
+ * \post             The complete framework of functions, types, globals
+ *                   prototypes and definitions to handle queues based on
+ *                   typesave
+ *                   lists for the given datatype are generated within the
+ *                   calling build file.
+ *
+ * \brief create complete framework to handle queues based on typesafe lists.
+ *
+ * This macro first colls GEN_QUEUE_PROTO() to create all prototypes
+ * neccesary for handling queues of the given \a type. And then it calls
+ * GEN_QUEUE_IMPL() to also create the neccesary definitions and
+ * implementations.\
+ * Normally this macro is only called if one only wants to have queues
+ * of the given type in a single c source file and nowhere else. Normally
+ * this is then used in conjunction with a previous define of GEN_LOCAL, 
+ * that tells GEN_QUEUE() and the subsequent macros to generate the functions
+ * as static.\n
+ * If one wants to used queues of the given type in several places of the
+ * project one would normally call GEN_QUEUE_PROTO() in a h file and 
+ * GEN_QUEUE_IMPL() in the c file that does the implementation of that
+ * h file (without GEN_LOCAL).
+ */
+#define  GEN_QUEUE(type)                                    \
+   GEN_QUEUE_PROTO (type)                                   \
+   GEN_QUEUE_IMPL (type)
+
+#endif   /* QUEUE_H */

+/**
+ * \file scot/queue_func_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro that produces function prototypes for handling queues
+ *          based on linked lists.
+ *
+ * The macros here create all function prototypes to 
+ * the implementations created by the macros in 
+ * \link scot/queue_impl.h scot/queue_impl.h\endlink.
+ * These macros are normally not called directly within your code but
+ * through \link scot/queue_proto.h::GEN_QUEUE_PROTO GEN_QUEUE_PROTO\endlink. 
+ * This is because to use the interface declaration
+ * provided here one will also need the typedefs and datatype prototypes.
+ * 
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  QUEUE_FUNC_PROTO_H
+#define  QUEUE_FUNC_PROTO_H
+
+
+#ifdef   GEN_LOCAL
+#  define   STATIC   static
+#else
+#  define   STATIC
+#endif
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_FUNC_PROTO should have bin called previously
+ *                   in one or the other way.
+ * \return           Nothing
+ * \post             All function prototypes for a queue of the given 
+ *                   datatype are created.
+ *
+ * \brief This creates the prototypes to all queue functions
+ *
+ * This creates all the prototypes to the functions that are created by
+ * \link scot/queue_impl.h::GEN_QUEUE_IMPL GEN_QUEUE_IMPL\endlink in 
+ * \link scot/queue_impl.h scot/queue_impl.h\endlink.
+ * This provides one with the complete interface to the queue of the given
+ * datatype.
+ */
+#define  GEN_QUEUE_FUNC_PROTO(type)                                  \
+   STATIC                                                            \
+   queue_ ## type ## _node_t *                                       \
+   queue_ ## type ## _new (                                          \
+         queue_ ## type ## _node_t *);                               \
+                                                                     \
+   STATIC                                                            \
+   void                                                              \
+   queue_ ## type ## _free (                                         \
+         queue_ ## type ## _node_t *);                               \
+                                                                     \
+   STATIC                                                            \
+   queue_ ## type ## _node_t *                                       \
+   queue_ ## type ## _enqueue (                                      \
+         queue_ ## type ## _node_t *,                                \
+         const type                *);                               \
+                                                                     \
+   STATIC                                                            \
+   type *                                                            \
+   queue_ ## type ## _dequeue (                                      \
+         queue_ ## type ## _node_t *);                               \
+                                                                     \
+   STATIC                                                            \
+   type *                                                            \
+   queue_ ## type ## _top (                                          \
+         queue_ ## type ## _node_t *);
+
+#endif   /* QUEUE_FUNC_PROTO_H */

+/**
+ * \file scot/queue_impl.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Templates of functions for handling  queues based on typesafe lists.
+ *
+ * The Macros here generate the implementation for the interface to queues
+ * based on typesafe linked lists.
+ * \anchor onlyfunc_queue
+ * \attention
+ * All documentation here does document the functions that are created by
+ * the macros, as the macros themself are pretty easy and all used the same.
+ * They are called with a type, that MUST be one word (use typedef if needed)
+ * and generates the function defined with their value.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  QUEUE_IMPL_H
+#define  QUEUE_IMPL_H
+
+#include <scot/list.h>
+
+
+/**
+ * \internal
+ * \param   type     the datatype that this queue code should handle.
+ * \param   a        a variable holding a pointer to list_[type]_node_t.
+ *
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   a must be a valid pointer to a list_[type]_node_t.
+ * \returns          \a a cast to a pointer of queue_[type]_node_t.
+ * \post             None
+ *
+ * \brief   Cast a pointer to queue_[type]_node_t.
+ *
+ * FIXME: I should check better the validity of \a a.
+ */
+#define  QUEUE(type, a) (queue_ ## type ## _node_t *) (a)
+
+extern const char *queue_err_msg[];
+
+
+#ifdef   GEN_LOCAL
+#  define   STATIC   static
+#else
+#  define   STATIC
+#endif
+
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_queue "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_NEW(type) has to be called previously.
+ * \return           NULL on error, but only if no exceptions are used.
+ *                   If exceptions are used an exception is thrown on error.
+ *                   On success a pointer to the newly created list_anchor
+ *                   will be returned.
+ * \retval  NULL     if an error occurs and no exceptions are used.
+ * \retval  !=NULL   the pointer to the newly created list anchor.
+ * \post             enough memory on the heap.
+ *
+ * \brief template for queue constructor.
+ *
+ * this simply calls list_[type]_new(), that must be generated previously
+ * by a call of GEN_LIST_NEW(type).
+ */
+#define  GEN_QUEUE_NEW(type)                                         \
+   STATIC                                                            \
+   queue_ ## type ## _node_t *                                       \
+   queue_ ## type ## _new (queue_ ## type ## _node_t *anchor)        \
+   {                                                                 \
+      return anchor = QUEUE (type,                                   \
+            list_ ## type ## _new (LIST (type, anchor)));            \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_queue "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_FREE(type) has to be called previously.
+ * \return           Nothing
+ * \post             The list is completely removed from the heap.
+ *
+ * \brief template for queue destructor.
+ *
+ * this simply calls list_[type]_free(), that must be generated previously
+ * by a call of GEN_LIST_FREE(type).
+ */
+#define  GEN_QUEUE_FREE(type)                                        \
+   STATIC                                                            \
+   void                                                              \
+   queue_ ## type ## _free (queue_ ## type ## _node_t *anchor)       \
+   {                                                                 \
+      list_ ## type ## _free (LIST (type, anchor));                  \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_queue "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \param   e        A pointer to a variable of the \a type, the
+ *                   list was created for.
+ * \pre              GEN_LIST_LAST(type) and GEN_LIST_INSERT(type)
+ *                   has to be called previously.
+ * \return           The inserted element \a e.
+ * \post             Element \a e is enqueued in the queue pointed by
+ *                   \a anchor.
+ *
+ * \brief template for a function that enqueues a value into a queue.
+ *
+ * To add a value into a queue meens to put it at the end of the queue.
+ * That is done by getting the last node of the list and insert a value
+ * behind it.
+ */
+#define  GEN_QUEUE_ENQUEUE(type)                                     \
+   queue_ ## type ## _node_t *                                       \
+   queue_ ## type ## _enqueue (                                      \
+         queue_ ## type ## _node_t  *anchor,                         \
+         const type                 *e)                              \
+   {                                                                 \
+      return QUEUE (type, list_ ## type ## _insert (                 \
+            list_ ## type ## _last (LIST (type, anchor)), e));       \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_queue "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_NEXT(type), GEN_LIST_RETRIVE(type)
+ *                   GEN_LIST_ISEMPTY(type) and GEN_LIST_DELETE(type)
+ *                   has to be called previously.
+ * \return           The dequeued element.
+ * \post             One Element is dequeued from the queue pointed to
+ *                   by \a anchor.
+ *
+ * \brief template for a function that dequeues a value from a queue.
+ *
+ * Dequeue means get and remove the first element from the queue.
+ * This is done here.
+ */
+#define  GEN_QUEUE_DEQUEUE(type)                                     \
+   STATIC                                                            \
+   type *                                                            \
+   queue_ ## type ## _dequeue (queue_ ## type ## _node_t  *anchor)   \
+   {                                                                 \
+      list_ ## type ## _node_t   *next;                              \
+      const type                 *e;                                 \
+                                                                     \
+      next  = list_ ## type ## _next (LIST (type, anchor));          \
+      e     = list_ ## type ## _retrive (next);                      \
+                                                                     \
+      if (! list_ ## type ## _isempty (next))                        \
+         list_ ## type ## _delete (next);                            \
+                                                                     \
+      return (type *) e;                                             \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_queue "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_NEXT(type) and GEN_LIST_RETRIVE(type)
+ *                   has to be called previously.
+ * \return           The next element in the queue.
+ * \post             None
+ *
+ * \brief get next element in the queue without dequeueing it.
+ */
+#define  GEN_QUEUE_TOP(type)                                         \
+   STATIC                                                            \
+   type *                                                            \
+   queue_ ## type ## _top (                                          \
+         queue_ ## type ## _node_t *anchor)                          \
+   {                                                                 \
+      return list_ ## type ## _retrive (                             \
+            list_ ## type ## _next (LIST (type, anchor)));           \
+   }
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_IMPL(type) should be called before this.
+ * \return           Nothing
+ * \post             The functions, struct and globals to handle queues
+ *                   based on typesave
+ *                   lists for the given datatype are generated within the
+ *                   calling build file.
+ *
+ * \brief this creates all functions, structs and globals needed for a
+ *        queue based on typesafe list of a given \a type.
+ *
+ * In detail the following is created by this macro:\n
+ * \li <b>struct queue_[type]_node_t</b>: This is the structure a queue
+ * is constructed of. Practically this just contains an instance of a
+ * list_[type]_node_t, as queues are completely based on lists and does
+ * not add further information.
+ * \li all functions created by the macros defined within this file.
+ */
+#define  GEN_QUEUE_IMPL(type)                                        \
+   struct queue_ ## type ## _node_t                                  \
+   {                                                                 \
+      struct list_ ## type ## _node_t  list;                         \
+   };                                                                \
+                                                                     \
+   GEN_QUEUE_NEW (type)                                              \
+   GEN_QUEUE_FREE (type)                                             \
+   GEN_QUEUE_ENQUEUE (type)                                          \
+   GEN_QUEUE_DEQUEUE (type)                                          \
+   GEN_QUEUE_TOP (type)
+
+#endif   /* QUEUE_IMPL_H */

+/**
+ * \file scot/queue_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   This generates all prototypes needed for queues based on
+ *          typesafe lists.
+ *
+ * This combines the macro definitions in \link scot/queue_type_proto.h 
+ * scot/queue_type_proto.h \endlink and \link scot/queue_func_proto.h 
+ * scot/queue_func_proto.h \endlink.
+ * Additionally defines for all errornumbers that queue will create can be
+ * found here.
+ * GEN_QUEUE_PROTO is normally called in a header file that describes a 
+ * new Datatype and also wants lists of it.
+ * By doing this the complete interface to lists of that datatype is
+ * produced.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  QUEUE_PROTO_H
+#define  QUEUE_PROTO_H
+
+#include <scot/queue_type_proto.h>
+#include <scot/queue_func_proto.h>
+
+/** 
+ * \brief errnum if queue is empty 
+ * \attention This is actually not use and will probably never be used
+ * in this form.
+ */
+#define  QUEUE_EMPTY         0
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_PROTO(type) should have been called previous
+ *                   to this call.
+ * \return           Nothing
+ * \post             The typedefs, struct declaration and function prototypes
+ *                   for functions to queues based on lists for the given 
+ *                   datatype are generated within the calling build file.
+ *
+ * \brief this creates all typdefs, declarations and prototypes needed for a
+ *        queue based on typesafe list of a given \a type. 
+ *        This is normally calles within a header file.
+ */
+#define  GEN_QUEUE_PROTO(type)                                       \
+   GEN_QUEUE_TYPE_PROTO (type)                                       \
+   GEN_QUEUE_FUNC_PROTO (type)
+
+#endif   /* QUEUE_PROTO_H */

+/**
+ * \file scot/queue_type_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro that creates the datatype for handling queues based on
+ *          linked lists.
+ *
+ * The macros here create all datatype prototypes and typedefs declarations to 
+ * the implementations created by the macros in 
+ * \link scot/queue_impl.h scot/queue_impl.h\endlink.
+ * These macros are normally not called directly within your code but
+ * through \link scot/queue_proto.h::GEN_QUEUE_PROTO GEN_QUEUE_PROTO\endlink. 
+ * This is because normally one did not only
+ * want the datatypes but also the interface declaration to them.
+ * 
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  QUEUE_TYPE_PROTO_H
+#define  QUEUE_TYPE_PROTO_H
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_TYPE_PROTO(type) should have been called
+ *                   previous to this.
+ * \return           Nothing
+ * \post             The datatype prototypes for queues based on lists 
+ *                   of the given datatype are created.
+ *
+ * \brief Datatype prototypes to queues.
+ *
+ * This creates the prototypes of the datatypes needed to use the
+ * queue interface.
+ *
+ * Normally this is not called directly, but by 
+ * \link scot/queue_proto.h::GEN_QUEUE_PROTO GEN_QUEUE_PROTO()\endlink 
+ * because it is also neccesary to create the interface to this 
+ * datatypes for working queues.
+ */
+#define  GEN_QUEUE_TYPE_PROTO(type)                                  \
+   struct queue_ ## type ## _node_t;                                 \
+   typedef struct queue_ ## type ## _node_t                          \
+      queue_ ## type ## _node_t;
+
+#endif   /* QUEUE_TYPE_PROTO_H */

+#ifndef  SCOT_EXCEPTIONS_H
+#define  SCOT_EXCEPTIONS_H
+
+#include <stdlib.h>
+
+#include <scot/scot_types.h>
+
+
+#define  MALLOC_ERR     0x00
+#define  NULL_PTR_ERR   0x01
+
+extern const char *scot_err_msg[];
+
+void *   exc_malloc     (SIZE_T);
+void *   exc_malloc_fl  (SIZE_T, const char *, int);
+void     check_null     (const void *);
+void     check_null_fl  (const void *, const char *, int);
+
+#endif   /* SCOT_EXCEPTIONS_H */

+#ifndef SCOT_SOCKET_H
+#define SCOT_SOCKET_H
+
+#include <scot_common.h>
+#include <scot/scot_types.h>
+
+#ifndef WIN32
+# include <netdb.h>
+# include <sys/socket.h>
+# include <sys/un.h>
+# include <arpa/inet.h>
+# include <netinet/in.h>
+# include <stdlib.h>
+# include <errno.h>
+
+# define INVALID_SOCKET  -1
+# define SCOT_ERRNO      errno
+# define SCOT_H_ERRNO    h_errno
+# define SOCKET          int
+# define SCOT_SOCK_CLOSE close
+#else
+# include <winsock.h>
+
+# define SCOT_ERRNO      WSAGetLastError()
+# define SCOT_H_ERRNO    WSAGetLastError()
+# define SCOT_SOCK_CLOSE closesocket
+#endif /* WIN32 */
+
+#include <scot/stream.h>
+
+/*
+ * prevent direct access to the structure
+ * from other methods then the ones that are made for this.
+ * Should especially encourage the use of getter and setter
+ * functions
+ */
+#ifndef USE_STRUCT_SCOT_SOCKET
+struct scot_socket
+{
+	const char _ [sizeof (struct {
+			struct scot_stream socket;
+			struct sockaddr *  sa;
+			SIZE_T             addr_len;
+			})];
+};
+#else
+struct scot_socket
+{
+	struct scot_stream socket;
+	struct sockaddr *  sa;
+	SIZE_T             addr_len;
+};
+#endif /* USE_STRUCT_SCOT_SOCKET */
+
+/* socket errors */
+#define SCOT_SOCKET_NEW_FAIL           0
+#define SCOT_SOCKET_LISTEN_FAIL        1
+#define SCOT_SOCKET_ACCEPT_FAIL        2
+#define SCOT_SOCKET_CONNECT_FAIL       3
+#define SCOT_SOCKET_NO_VALID_HOST      4
+#define SCOT_SOCKET_AF_NOT_IMPLEMENTED 5
+/* socket warnings */
+#define SCOT_SOCKET_UN_FILE_EXISTS     0
+extern const char * scot_socket_errmsg[];
+extern const char * scot_socket_wrnmsg[];
+
+/* 
+ * This function initializes scot sockets. This primary means it does
+ * nothing under a posix system an WSASartup on a Windows system.
+ */
+void                 scot_socket_init    (uint16_t, uint16_t);
+/*
+ * This finalizes the scot sockets system. Again does noting on posix
+ * and WSACleanup on Windows.
+ */
+void                 scot_socket_fini    (void);
+
+void                 scot_socket_listen  (const struct scot_socket*);
+struct scot_socket * scot_socket_accept  (const struct scot_socket*);
+void                 scot_socket_connect (const struct scot_socket*, 
+                                          const char *);
+
+void                 scot_socket_free    (struct scot_socket*);
+
+#endif /* SCOT_SOCKET_H */

+#ifndef SCOT_SOCKET_IN_H
+#define SCOT_SOCKET_IN_H
+
+extern const char * scot_socket_errmsg[];
+
+
+struct scot_socket * scot_socket_in_new      (const char*, const char*);
+struct scot_socket * scot_socket_in_accept   (const struct scot_socket*);
+void                 scot_socket_in_prep_con (const struct scot_socket *, 
+                                              const char *);
+
+const char * scot_socket_in_get_host         (struct scot_socket *);
+const char * scot_socket_in_get_ddc          (struct scot_socket *);
+
+#endif /* SCOT_SOCKET_IN_H */

+#ifndef SCOT_SOCKET_UN_H
+#define SCOT_SOCKET_UN_H
+
+extern const char * scot_socket_errmsg[];
+
+
+struct scot_socket * scot_socket_un_new      (const char*);
+struct scot_socket * scot_socket_un_accept   (const struct scot_socket*);
+void                 scot_socket_un_prep_con (const struct scot_socket *, 
+                                              const char *);
+
+const char * scot_socket_un_get_path         (struct scot_socket*);
+
+#endif /* SCOT_SOCKET_UN_H */

+/**
+ * \file scot/stack.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro which produce all prototypes and implementations for 
+ *          handling stacks based on linked lists by Templates.
+ *
+ * This is the toplevel template file for stacks based on typesafe lists. 
+ * It is quite simple. It just defines one MACRO which in turn calls two 
+ * other macros to generate all that is needed for queue-handling of a queue 
+ * to a given type.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_H
+#define  STACK_H
+
+#include <scot/stack_proto.h>
+#include <scot/stack_impl.h>
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST(type) has to be called for the list functions,
+ *                   as queues depend on these.
+ * \return           Nothing
+ * \post             The complete framework of functions, types, globals
+ *                   prototypes and definitions to handle stacks based on
+ *                   typesafe
+ *                   lists for the given datatype are generated within the
+ *                   calling build file.
+ *
+ * \brief create complete framework to handle stacks based on typesafe lists.
+ *
+ * This macro first colls GEN_STACK_PROTO() to create all prototypes
+ * neccesary for handling stacks of the given \a type. And then it calls
+ * GEN_STACK_IMPL() to also create the neccesary definitions and
+ * implementations.\
+ * Normally this macro is only called if one only wants to have stacks
+ * of the given type in a single c source file and nowhere else. Normally
+ * this is then used in conjunction with a previous define of GEN_LOCAL, 
+ * that tells GEN_STACK() and the subsequent macros to generate the functions
+ * as static.\n
+ * If one wants to used queues of the given type in several places of the
+ * project one would normally call GEN_STACK_PROTO() in a h file and 
+ * GEN_STACK_IMPL() in the c file that does the implementation of that
+ * h file (without GEN_LOCAL).
+ */
+#define  GEN_STACK(type)                                    \
+   GEN_STACK_PROTO (type)                                   \
+   GEN_STACK_IMPL (type)
+
+#endif   /* STACK_H */

+/**
+ * \file scot/stack_func_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro that produces function prototypes for handling stacks
+ *          based on linked lists.
+ *
+ * The macros here create all function prototypes to 
+ * the implementations created by the macros in 
+ * \link scot/stack_impl.h scot/stack_impl.h\endlink.
+ * These macros are normally not called directly within your code but
+ * through \link scot/stack_proto.h::GEN_STACK_PROTO GEN_STACK_PROTO\endlink. 
+ * This is because to use the interface declaration
+ * provided here one will also need the typedefs and datatype prototypes.
+ * 
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_FUNC_PROTO_H
+#define  STACK_FUNC_PROTO_H
+
+
+#ifdef   GEN_LOCAL
+#  define   STATIC   static
+#else
+#  define   STATIC
+#endif
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_FUNC_PROTO should have bin called previously
+ *                   in one or the other way.
+ * \return           Nothing
+ * \post             All function prototypes for a stack of the given 
+ *                   datatype are created.
+ *
+ * \brief This creates the prototypes to all stack functions
+ *
+ * This creates all the prototypes to the functions that are created by
+ * \link scot/stack_impl.h::GEN_STACK_IMPL GEN_STACK_IMPL\endlink in 
+ * \link scot/stack_impl.h scot/stack_impl.h\endlink.
+ * This provides one with the complete interface to the stack of the given
+ * datatype.
+ */
+#define  GEN_STACK_FUNC_PROTO(type)                                  \
+   STATIC                                                            \
+   stack_ ## type ## _node_t *                                       \
+   stack_ ## type ## _new (                                          \
+         stack_ ## type ## _node_t *);                               \
+                                                                     \
+   STATIC                                                            \
+   void                                                              \
+   stack_ ## type ## _free (                                         \
+         stack_ ## type ## _node_t *);                               \
+                                                                     \
+   STATIC                                                            \
+   stack_ ## type ## _node_t *                                       \
+   stack_ ## type ## _push (                                         \
+         stack_ ## type ## _node_t *,                                \
+         const type                *);                               \
+                                                                     \
+   STATIC                                                            \
+   type *                                                            \
+   stack_ ## type ## _pop (                                          \
+         stack_ ## type ## _node_t *);                               \
+                                                                     \
+   STATIC                                                            \
+   type *                                                            \
+   stack_ ## type ## _top (                                          \
+         stack_ ## type ## _node_t *);
+
+#endif   /* STACK_FUNC_PROTO_H */

+/**
+ * \file scot/stack_impl.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Templates of functions for handling stacks based on typesafe lists.
+ *
+ * The Macros here generate the implementation for the interface to stacks
+ * based on typesafe linked lists.
+ * \anchor onlyfunc_stack
+ * \attention
+ * All documentation here does document the functions that are created by
+ * the macros, as the macros themself are pretty easy and all used the same.
+ * They are called with a type, that MUST be one word (use typedef if needed)
+ * and generates the function defined with their value.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_IMPL_H
+#define  STACK_IMPL_H
+
+#include <scot/list.h>
+
+
+/**
+ * \internal
+ * \param   type     the datatype that this queue code should handle.
+ * \param   a        a variable holding a pointer to list_[type]_node_t.
+ *
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   a must be a valid pointer to a list_[type]_node_t.
+ * \returns          \a a cast to a pointer of stack_[type]_node_t.
+ * \post             None
+ *
+ * \brief   Cast a pointer to stack_[type]_node_t.
+ *
+ * FIXME: I should check better the validity of \a a.
+ */
+#define  STACK(type, a) (stack_ ## type ## _node_t *) (a)
+
+extern const char *stack_err_msg[];
+
+
+#ifdef   GEN_LOCAL
+#  define   STATIC   static
+#else
+#  define   STATIC
+#endif
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_stack "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_NEW(type) has to be called previously.
+ * \return           NULL on error, but only if no exceptions are used.
+ *                   If exceptions are used an exception is thrown on error.
+ *                   On success a pointer to the newly created list_anchor
+ *                   will be returned.
+ * \retval  NULL     if an error occurs and no exceptions are used.
+ * \retval  !=NULL   the pointer to the newly created list anchor.
+ * \post             enough memory on the heap.
+ *
+ * \brief template for stack constructor.
+ *
+ * this simply calls list_[type]_new(), that must be generated previously
+ * by a call of GEN_LIST_NEW(type).
+ */
+#define  GEN_STACK_NEW(type)                                         \
+   STATIC                                                            \
+   stack_ ## type ## _node_t *                                       \
+   stack_ ## type ## _new (stack_ ## type ## _node_t *anchor)        \
+   {                                                                 \
+      return anchor = STACK (type,                                   \
+            list_ ## type ## _new (LIST (type, anchor)));            \
+   }
+   
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_stack "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_FREE(type) has to be called previously.
+ * \return           Nothing
+ * \post             The list is completely removed from the heap.
+ *
+ * \brief template for stack destructor.
+ *
+ * this simply calls list_[type]_free(), that must be generated previously
+ * by a call of GEN_LIST_FREE(type).
+ */
+#define  GEN_STACK_FREE(type)                                        \
+   STATIC                                                            \
+   void                                                              \
+   stack_ ## type ## _free (stack_ ## type ## _node_t *anchor)       \
+   {                                                                 \
+      list_ ## type ## _free (LIST (type, anchor));                  \
+   }
+   
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_stack "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \param   e        A pointer to a variable of the \a type, the
+ *                   list was created for.
+ * \pre              GEN_LIST_INSERT(type) has to be called previously.
+ * \return           The pushed element \a e.
+ * \post             Element \a e is pushed in the stack pointed by
+ *                   \a anchor.
+ *
+ * \brief template for a function that pushes a value into a stack.
+ *
+ * To add a value into a stack meens to put it at the beginning of the stack.
+ * That is simply a call to list_[type]_insert().
+ */
+#define  GEN_STACK_PUSH(type)                                        \
+   STATIC                                                            \
+   stack_ ## type ## _node_t *                                       \
+   stack_ ## type ## _push (                                         \
+         stack_ ## type ## _node_t  *anchor,                         \
+         const type                 *e)                              \
+   {                                                                 \
+      return STACK (type, list_ ## type ## _insert (                 \
+            LIST (type, anchor), e));                                \
+   }
+
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_stack "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_NEXT(type), GEN_LIST_RETRIVE(type)
+ *                   GEN_LIST_ISEMPTY(type) and GEN_LIST_DELETE(type)
+ *                   has to be called previously.
+ * \return           The poped element.
+ * \post             One Element is poped from the stack pointed to
+ *                   by \a anchor.
+ *
+ * \brief template for a function that pops a value from a stack.
+ *
+ * Pop means get and remove the first element from the stack.
+ * This is done here.
+ */
+#define  GEN_STACK_POP(type)                                         \
+   STATIC                                                            \
+   type *                                                            \
+   stack_ ## type ## _pop (stack_ ## type ## _node_t  *anchor)       \
+   {                                                                 \
+      list_ ## type ## _node_t   *next;                              \
+      const type                 *e;                                 \
+                                                                     \
+      next  = list_ ## type ## _next (LIST (type, anchor));          \
+      e     = list_ ## type ## _retrive (next);                      \
+                                                                     \
+      if (! list_ ## type ## _isempty (next))                        \
+         list_ ## type ## _delete (next);                            \
+                                                                     \
+      return (type *) e;                                             \
+   }
+   
+/**
+ * \attention
+ * Only the generated function is explained here, for the reason look
+ * \ref onlyfunc_stack "here".
+ *
+ * \param   anchor   a pointer that should contain the list anchor.
+ * \pre              GEN_LIST_NEXT(type) and GEN_LIST_RETRIVE(type)
+ *                   has to be called previously.
+ * \return           The next element in the stack.
+ * \post             None
+ *
+ * \brief get next element in the stack without poping it.
+ */
+#define  GEN_STACK_TOP(type)                                         \
+   STATIC                                                            \
+   type *                                                            \
+   stack_ ## type ## _top (                                          \
+         stack_ ## type ## _node_t *anchor)                          \
+   {                                                                 \
+      return list_ ## type ## _retrive (                             \
+            list_ ## type ## _next (LIST (type, anchor)));           \
+   }
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_IMPL(type) should be called before this.
+ * \return           Nothing
+ * \post             The functions, struct and globals to handle stacks
+ *                   based on typesave
+ *                   lists for the given datatype are generated within the
+ *                   calling build file.
+ *
+ * \brief this creates all functions, structs and globals needed for a
+ *        stack based on typesafe list of a given \a type.
+ *
+ * In detail the following is created by this macro:\n
+ * \li <b>struct stack_[type]_node_t</b>: This is the structure a stack
+ * is constructed of. Practically this just contains an instance of a
+ * list_[type]_node_t, as stacks are completely based on lists and does
+ * not add further information.
+ * \li all functions created by the macros defined within this file.
+ */
+#define  GEN_STACK_IMPL(type)                                        \
+   struct stack_ ## type ## _node_t                                  \
+   {                                                                 \
+      struct list_node_t  list;                                      \
+   };                                                                \
+                                                                     \
+   GEN_STACK_NEW (type)                                              \
+   GEN_STACK_FREE (type)                                             \
+   GEN_STACK_PUSH (type)                                             \
+   GEN_STACK_POP (type)                                              \
+   GEN_STACK_TOP (type)
+
+#endif   /* STACK_IMPL_H */

+/**
+ * \file scot/stack_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   This generates all prototypes needed for stacks based on
+ *          typesafe lists.
+ *
+ * This combines the macro definitions in \link scot/stack_type_proto.h 
+ * scot/stack_type_proto.h \endlink and \link scot/stack_func_proto.h 
+ * scot/stack_func_proto.h \endlink.
+ * Additionally defines for all errornumbers that stack will create can be
+ * found here.
+ * GEN_STACK_PROTO is normally called in a header file that describes a 
+ * new Datatype and also wants lists of it.
+ * By doing this the complete interface to lists of that datatype is
+ * produced.
+ *
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_PROTO_H
+#define  STACK_PROTO_H
+
+#include <scot/stack_type_proto.h>
+#include <scot/stack_func_proto.h>
+
+/** 
+ * \brief errnum if stack is empty 
+ * \attention This is actually not use and will probably never be used
+ * in this form.
+ */
+#define  STACK_EMPTY         0
+
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_PROTO(type) should have been called previous
+ *                   to this call.
+ * \return           Nothing
+ * \post             The typedefs, struct declaration and function prototypes
+ *                   for functions to stacks based on lists for the given 
+ *                   datatype are generated within the calling build file.
+ *
+ * \brief this creates all typdefs, declarations and prototypes needed for a
+ *        stack based on typesafe list of a given \a type. 
+ *        This is normally calles within a header file.
+ */
+#define  GEN_STACK_PROTO(type)                                       \
+   GEN_STACK_TYPE_PROTO (type)                                       \
+   GEN_STACK_FUNC_PROTO (type)
+
+#endif   /* STACK_PROTO_H */

+/**
+ * \file scot/stack_type_proto.h
+ * \author  Georg Steffers <georg@steffers.org>
+ * \brief   Macro that creates the datatype for handling stacks based on
+ *          linked lists.
+ *
+ * The macros here create all datatype prototypes and typedefs declarations to 
+ * the implementations created by the macros in 
+ * \link scot/stack_impl.h scot/stack_impl.h\endlink.
+ * These macros are normally not called directly within your code but
+ * through \link scot/stack_proto.h::GEN_STACK_PROTO GEN_STACK_PROTO\endlink. 
+ * This is because normally one did not only
+ * want the datatypes but also the interface declaration to them.
+ * 
+ * Copyright (C)2006    Georg Steffers <georg@steffers.org>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef  STACK_TYPE_PROTO_H
+#define  STACK_TYPE_PROTO_H
+
+/**
+ * \param   type     the datatype that this list code should handle.
+ * \pre              Type must be a single word typename. If one wants
+ *                   to use e.g. lists of structs one has to use typedef
+ *                   to create a single word type name like this:
+ *                   typedef struct mystruct_t mystruct_t;
+ *                   GEN_LIST_TYPE_PROTO(type) should have been called
+ *                   previous to this.
+ * \return           Nothing
+ * \post             The datatype prototypes for stacks based on lists 
+ *                   of the given datatype are created.
+ *
+ * \brief Datatype prototypes to stacks.
+ *
+ * This creates the prototypes of the datatypes needed to use the
+ * stack interface.
+ *
+ * Normally this is not called directly, but by 
+ * \link scot/stack_proto.h::GEN_STACK_PROTO GEN_STACK_PROTO()\endlink 
+ * because it is also neccesary to create the interface to this 
+ * datatypes for working stacks.
+ */
+#define  GEN_STACK_TYPE_PROTO(type)                                  \
+   struct stack_ ## type ## _node_t;                                 \
+   typedef struct stack_ ## type ## _node_t                          \
+      stack_ ## type ## _node_t;                                     \
+
+#endif   /* STACK_TYPE_PROTO_H */

+/*
+ * Zunächst ein paar allgemeine Bemerkungen zu scot_stream:
+ *
+ * 1. scot-stream ist eine auf andere Klassen aufbauende Klasse. Es gibt
+ *    kein scot_stream_new. Mann kann natürlich über malloc ein leeres
+ *    stream-objekt anlegen, das macht für gewöhnlich aber keinen Sinn.
+ *    Stattdessen gibt es in Klassen, die stream-io Endpunkte darstellen
+ *    Funktionen der Form scot_<Klasse>_get_new_stream 
+ *    (z.B. scot_socket_get_new_stream). Diese Funktionen geben ein
+ *    gültiges Stream Objekt zu einem Objekt der übergeordneten Klasse
+ *    zurück. Das Objekt der übergeordnete Klasse muss sich alle auf diese 
+ *    Art angelegten Stream-Objekte merken.
+ * 2. Wenn ein Objekt der übergeordneten Klasse geschlossen wird, so werden
+ *    auch alle Stream Objekte die von diesem erzeugt wurden freigegeben und
+ *    auf NULL gesetzt. (Auf Sie währe eh keine Sinnvolle operation mehr
+ *    möglich.)
+ * 3. Wird ein Stream-Objekt freigegeben, so bleibt das übergeordnete
+ *    Objekt erhalten (und somit auch der handle geöffnet).
+ * 4. Ein close auf ein Stream Objekt schließt auch das übergeordnete
+ *    Objekt und gibt es frei. Somit werden auch alle weiteren Stream
+ *    Objekte geschlossen.
+ *
+ * !!!Zusammenfassend bleibt nochmal hervorzuheben das close gegenüber free
+ *    die stärkere operation ist und zu einem free aller stream objekte und
+ *    des übergeordneten Objekts führt.!!!
+ */
+#ifndef SCOT_STREAM_H
+#define SCOT_STREAM_H
+
+#include <scot/scot_int.h>
+#include <scot/scot_types.h>
+
+#define SCOT_STREAM_BUF_SIZE		100
+
+/* scot stream types (scot_stream:s_type) . */
+/* Die ersten bis zum --- Kommentar sind stream_pool fähig */
+#define SCOT_STREAM_TYPE_SOCKET  0
+#define SCOT_STREAM_TYPE_PIPE    1
+#define SCOT_STREAM_TYPE_TERM    2
+/* --- */
+#define SCOT_STREAM_TYPE_FILE    3
+#define SCOT_STREAM_TYPE_INOTIFY 4
+
+#ifdef WIN32
+# include <Windows.h>
+# include <scot/stream_win.h>
+# define SCOT_FILE_READ  win_file_read
+#else
+# define SCOT_FILE_READ  read
+#endif /* WIN32 */
+
+/* s must me a pointer to a stream...this is normally the case! */
+#define SCOT_STREAM_TO_SOCKET(s)	 ((struct scot_socket *)(s))
+#define SCOT_STREAM_TO_PIPE(s)	 ((struct scot_pipe *)(s))
+#define SCOT_STREAM_TO_TERM(s)	 ((struct scot_term *)(s))
+#define SCOT_STREAM_TO_FILE(s)	 ((struct scot_file *)(s))
+#define SCOT_STREAM_TO_INOTIFY(s) ((struct scot_inotify *)(s))
+
+/* 
+ * get the base object of the given stream with the correct type 
+ * Those base types has to be specified here at the moment... maybe
+ * sometimes there will be some kind of registration method for 
+ * base types
+ */
+#define SCOT_STREAM_PROV(st) \
+	((st)->s_type == SCOT_STREAM_TYPE_SOCKET)? SCOT_STREAM_TO_SOCKET((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_PIPE)?   SCOT_STREAM_TO_PIPE((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_TERM)?   SCOT_STREAM_TO_TERM((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_FILE)?   SCOT_STREAM_TO_FILE((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_INOTIFY)?SCOT_STREAM_TO_INOTIFY((st)):(st)
+
+#define SCOT_STREAM_FREE(st) \
+	((st)->s_type == SCOT_STREAM_TYPE_SOCKET)?\
+		scot_socket_free (SCOT_STREAM_TO_SOCKET (st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_PIPE)?   scot_stream_free ((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_TERM)?   scot_stream_free ((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_FILE)?   scot_stream_free ((st)):\
+	((st)->s_type == SCOT_STREAM_TYPE_INOTIFY)?scot_stream_free ((st)):\
+		scot_stream_free ((st))
+
+/* 
+ * connections via ssl must be handled separately, because communication
+ * over them has some very distinc behaviour then with other streams.
+ * First, read and write are not done on a handle but on an ssl object.
+ * Next, ssl has an all or nothing approach. If a write could not send
+ * all data it sould be assumed as failed. This is neccessary for the
+ * encryption.
+ * Next, ssl is designed to sit on top of most stream types. Thus it
+ * is a separate object, that should be createable by a stream object.
+ */
+
+struct scot_stream
+{
+#ifndef WIN32
+	union
+	{
+		int32_t file;
+		int32_t sock;
+	} handle;
+#else
+	union
+	{
+		HANDLE file;
+		SOCKET sock;
+	} handle;
+#endif
+	char     rbuf [SCOT_STREAM_BUF_SIZE];
+	char     wbuf [SCOT_STREAM_BUF_SIZE];
+	uint32_t rbuf_idx;
+	uint32_t wbuf_idx;
+	int32_t  s_type;   /* an identifier of this stream (file, socket, pipe...) */
+	int16_t  s_blk;
+};
+
+int     scot_stream_eof       (struct scot_stream *);
+SSIZE_T scot_stream_read      (struct scot_stream *, char *, SIZE_T);
+SSIZE_T scot_stream_write     (struct scot_stream *, char *, SIZE_T);
+void    scot_stream_flush     (struct scot_stream *);
+
+SSIZE_T scot_stream_read_pending  (struct scot_stream *);
+SSIZE_T scot_stream_write_pending (struct scot_stream *);
+
+int     scot_stream_get_blocking (struct scot_stream *);
+void    scot_stream_set_block    (struct scot_stream *);
+void    scot_stream_set_nonblock (struct scot_stream *);
+
+void    scot_stream_close     (struct scot_stream *);
+int     scot_stream_is_closed (struct scot_stream *);
+
+void    scot_stream_free      (struct scot_stream *);
+
+#endif /* SCOT_STREAM_H */

+#ifndef SCOT_STREAM_POOL_H
+#define SCOT_STREAM_POOL_H
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <scot/event_listener.h>
+#include <scot/stream.h>
+#include <scot/thread.h>
+#include <scot/stream_pool_fraction.h>
+
+#define GEN_LOCAL
+# include <scot/list.h>
+#undef  GEN_LOCAL
+
+/*
+ * folgende masken dienen dazu zu bestimmen in welches fd_set
+ * (read, write, exception) ein filehandle eingetragen werden soll.
+ * D.h. für welche operation der select diesen handle überwachen soll.
+ */
+#define SCOT_STREAM_POOL_FD_ADD_RMASK        0x1
+#define SCOT_STREAM_POOL_FD_ADD_WMASK        0x2
+#define SCOT_STREAM_POOL_FD_ADD_EMASK        0x4
+
+#define SCOT_STREAM_POOL_CLEANUP             0x00
+#define SCOT_STREAM_POOL_RESTART_FRACTION    0x01
+#define SCOT_STREAM_POOL_START_FRACTION      0x02
+#define SCOT_STREAM_POOL_STOP_FRACTION       0x03
+#define SCOT_STREAM_POOL_RESTART_ALL_FRAC    0x04
+#define SCOT_STREAM_POOL_START_ALL_FRAC      0x05
+#define SCOT_STREAM_POOL_STOP_ALL_FRAC       0x06
+
+#define SCOT_STREAM_POOL_KEEP_STREAMS        0x0
+#define SCOT_STREAM_POOL_FREE_STREAMS        0x1
+
+
+typedef struct scot_sp_fraction scot_sp_fraction;
+GEN_LIST_TYPE_PROTO (scot_sp_fraction);
+
+struct scot_stream_pool
+{
+	struct scot_event_listener el;
+
+	uint16_t cmd;
+	void *   cmd_arg;
+	THREAD_COND_T    cmd_cond;
+	THREAD_COND_CS_T cmd_cs;
+
+	list_scot_sp_fraction_node_t * pool;
+	THREAD_MUTEX_T mutex;
+};
+
+
+struct scot_stream_pool * scot_stream_pool_new     (struct scot_stream_pool *);
+void                      scot_stream_pool_free    (struct scot_stream_pool *);
+void                      scot_stream_pool_free_s  (struct scot_stream_pool *,
+                                                    int);
+void                      scot_stream_pool_add     (struct scot_stream_pool *, 
+                                                    struct scot_stream *,
+                                                    int);
+void                      scot_stream_pool_remove  (struct scot_stream_pool *,
+                                                    struct scot_stream *,
+                                                    int);
+int                       scot_stream_pool_get_rwe (struct scot_stream_pool *, 
+                                                    struct scot_stream *);
+void                      scot_stream_pool_cmd     (struct scot_stream_pool *,
+                                                    uint16_t,
+																	 void *);
+struct scot_stream *      scot_sp_get_all_streams  (struct scot_stream_pool *);
+
+#endif /* SCOT_STREAM_POOL_H */

+#ifndef SCOT_STREAM_POOL_FRACTION_H
+#define SCOT_STREAM_POOL_FRACTION_H
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <scot/stream_pool.h>
+#include <scot/event_listener.h>
+#include <scot/scot_int.h>
+#include <scot/stream.h>
+#include <scot/thread.h>
+
+#define SCOT_MAX_FRACTION		64 /* Windows kann max. 64 Objekte pro thread
+												überwachen. */
+												
+struct scot_sp_fraction
+{
+	struct scot_event_listener * el;
+
+	int                    stream_type; /* what streams to accept */
+
+	THREAD_T               thread_handle;
+	THREAD_ID_T            thread_id;
+	int                    thread_run_flg;
+
+	scot_thread_entry_fptr spf_entry_func; 
+
+	uint16_t               s_count;
+	struct scot_stream *   s_list [SCOT_MAX_FRACTION]; 
+	int                    free_s;
+
+	/* for select */
+	fd_set rfds, wfds, efds;
+	int max_fd;
+};
+
+extern scot_thread_entry_fptr scot_spf_thread_func[];
+
+struct scot_sp_fraction * scot_spf_new      (struct scot_sp_fraction *,
+                                             struct scot_event_listener *,
+                                             int);
+void                      scot_spf_free     (struct scot_sp_fraction *);
+void                      scot_spf_free_s   (struct scot_sp_fraction *,
+                                             int);
+void                      scot_spf_add      (struct scot_sp_fraction *, 
+                                             struct scot_stream *,
+														   int);
+void                      scot_spf_remove   (struct scot_sp_fraction *,
+                                             struct scot_stream *,
+														   int);
+
+#endif /* SCOT_STREAM_POOL_FRACTION_H */

+#ifndef SCOT_STREAM_WIN_H
+#define SCOT_STREAM_WIN_H
+
+#include <windows.h>
+
+SSIZE_T win_file_read (HANDLE, void *, SIZE_T);
+
+#endif /* SCOT_STREAM_WIN_H */

+/*
+ * used for threadsafety within exception
+ * actually only pthread is supported
+ */
+#ifndef  THREAD_H
+#define  THREAD_H
+
+#include <stdio.h>
+
+#define  JOIN_OK             0x00
+#define  JOIN_TIMEOUT        0x01
+#define  JOIN_ERROR          0x02
+
+/*
+ * i guess it is possible to write mutex code that uses cond
+ * elements to timeout on lock, but right now i have no clear
+ * idea of how to do this. The following thoughts i had:
+ * - create a struct that holds a pthread_mutex_t and a pthread_cond_t
+ *   for every mutex. 
+ * - lock mutexes only by calling pthread_cond_timedwait
+ * And here starts the problem...to do a cond_timedwait i need to ensure
+ * that the mutex is already locked...well and then a question i have not
+ * clearyfied, if a thread ends, will all locks on mutexes be removed?
+ * I guess so, but i did not test it. And an even more important question,
+ * is it possible to write cleanup-code that guarantees that a
+ * pthread_cond_signal is called for every mutex the thread holds...
+ * well, we will end up with the requirement that the programmer has to
+ * call a release mutex function before ending a thread and if the programmer
+ * forgets that the behaviour of out code is unspecified
+ * Right now i will not support timeouts on mutex-locks and to be consistent
+ * it is not supported on win32 either, also it would be much easier to
+ * implement there.
+ */
+#define  MUTEX_LOCK_OK       0x00
+#define  MUTEX_LOCK_ERROR    0x02
+
+#define   THREAD_T               int
+#define   THREAD_ID_T            int
+#define   THREAD_ID              0
+#define   SELF_THREAD            0
+#define   NEW_THREAD             perror ("No supported thread system used!\n")
+#define   CANCEL_THREAD(t)       NEW_THREAD
+#define   EXIT_THREAD(r)         NEW_THREAD
+#define   JOIN_THREAD(t,i)       NEW_THREAD
+#define   THREAD_CANCEL_ENABLE   NEW_THREAD
+#define   THREAD_CANCEL_DISABLE  NEW_THREAD
+#define   THREAD_CANCEL_ASYNC    NEW_THREAD
+#define   THREAD_CANCEL_DEFER    NEW_THREAD
+#define   T_PROC_RET             int
+
+#endif   /* THREAD_H */

+/*
+ * dir.h: as one might suggest here are definitions and prototypes for
+ *        win32/dir.c
+ *
+ * Copyright (C) 2006 Georg Steffers
+ *
+ * Author:    Georg Steffers [GST] <georg.steffers@aschendorff.de>
+ * Developer:
+ *
+ * Changes (for this file only):
+ *   (2006-06-12) [GST] Started this changelog...well the program is
+ *                      ready since some weeks right now.
+ */
+#ifndef DIR_H
+#define DIR_H
+
+#include <windows.h>
+
+#include <scot/dir_common.h>
+
+/* abstraction for file information and an directory handle */
+#define FILE_DATA       struct dir_file
+#define DIR_HANDLE      HANDLE
+
+/* abstraction for checking if a file is a directory */
+#define IS_DIRECTORY(file_data) \
+	((file_data).file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+
+/* abstraction for getting the filename of a directory entry. */
+#define DIRENT_FNAME(file_data) ((file_data).file.cFileName)
+
+/* structure for all available information about the directory entry. */
+struct dir_file
+{
+	char            path [MAX_PATH+1];
+	WIN32_FIND_DATA file;
+};
+
+/* the last in parameter is posix specific. It defines if stat should
+ * follow symlinks or not. Under Windows it is ignored. */
+DIR_HANDLE get_dir_first (const char *, FILE_DATA *, int);
+int        get_dir_next  (DIR_HANDLE, const char *, FILE_DATA *, int);
+
+#endif /* DIR_H */

+/***************************************************************************
+ * memory.h: Prototypes for default memory operations like memcpy and thus *
+ *           on a win32 system nearly all CRT functions (CRT is the        *
+ *           windows C RunTime, that is the normal libC) aren't thread-    *
+ *           safe. As i build up tests this causes problems for example    *
+ *           with strcpy. So i decided to write wrapper that use non CRT   *
+ *           functions on Windows and normal libC ones on a posix system.  *
+ *                                                                         *
+ * Author:   Georg Steffers <georg@steffers.org>                           *
+ * Date:     03/06/2006                                                    *
+ ***************************************************************************/
+#ifndef MEMORY_H
+#define MEMORY_H
+
+#include <windows.h>
+#include <sys/types.h>
+
+#include <scot_common.h>
+#include <scot/scot_types.h>
+
+#define SCOT_MEM_GET(s)       HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, (s));
+#define SCOT_MEM_FREE(p)      \
+   if ((p)) {HeapFree(GetProcessHeap(), 0, (p)); (p)=NULL;}
+#define SCOT_MEM_COPY(p,q,s)  (CopyMemory ((p), (q), (s)), (p))
+#define SCOT_MEM_MOVE(p,q,s)  (MoveMemory ((p), (q), (s)), (p))
+#define SCOT_MEM_FILL(p,v,s)  (FillMemory ((p), (s), (v)), (p))
+#define SCOT_MEM_ZERO         ZeroMemory
+#define SCOT_STR_LENGTH       str_length
+#define SCOT_STR_COPY         str_copy
+#define SCOT_STRN_COPY        strn_copy
+#define SCOT_STR_CHAR         str_char
+#define SCOT_STRR_CHAR        strr_char
+
+SIZE_T   str_length (const char *);
+char   * str_copy   (char *, const char *);
+char   * strn_copy  (char *, const char *, SIZE_T);
+char   * str_char   (const char *, int);
+char   * strr_char  (const char *, int);
+
+#endif /* MEMORY_H */

+#ifndef SCOT_TYPES_H
+#define SCOT_TYPES_H
+
+#include <Windows.h>
+
+#endif /* SCOT_TYPES_H */

+/*
+ * used for threadsafety within exception
+ * actually only pthread is supported
+ */
+#ifndef  THREAD_H
+#define  THREAD_H
+
+#include <stdio.h>
+#include  <windows.h>
+
+
+#define  JOIN_OK             0x00
+#define  JOIN_TIMEOUT        0x01
+#define  JOIN_ERROR          0x02
+
+/*
+ * i guess it is possible to write mutex code that uses cond
+ * elements to timeout on lock, but right now i have no clear
+ * idea of how to do this. The following thoughts i had:
+ * - create a struct that holds a pthread_mutex_t and a pthread_cond_t
+ *   for every mutex. 
+ * - lock mutexes only by calling pthread_cond_timedwait
+ * And here starts the problem...to do a cond_timedwait i need to ensure
+ * that the mutex is already locked...well and then a question i have not
+ * clearyfied, if a thread ends, will all locks on mutexes be removed?
+ * I guess so, but i did not test it. And an even more important question,
+ * is it possible to write cleanup-code that guarantees that a
+ * pthread_cond_signal is called for every mutex the thread holds...
+ * well, we will end up with the requirement that the programmer has to
+ * call a release mutex function before ending a thread and if the programmer
+ * forgets that the behaviour of out code is unspecified
+ * Right now i will not support timeouts on mutex-locks and to be consistent
+ * it is not supported on win32 either, also it would be much easier to
+ * implement there.
+ */
+#define  MUTEX_LOCK_OK       0x00
+#define  MUTEX_LOCK_ERROR    0x02
+
+#define   THREAD_T                   HANDLE
+#define   THREAD_ID_T                DWORD
+#define   THREAD_ID                  GetCurrentThreadId  ()
+#define   SELF_THREAD                GetCurrentThread    ()
+#define   NEW_THREAD                 thread_new
+#define   CANCEL_THREAD(thread)      (! TerminateThread  ((thread), -1))
+#define   EXIT_THREAD(retval)        _endthreadex ((DWORD) (retval))
+#define   JOIN_THREAD                thread_join
+#define   THREAD_CANCEL_ENABLE
+#define   THREAD_CANCEL_DISABLE
+#define   THREAD_CANCEL_ASYNC
+#define   THREAD_CANCEL_DEFER
+#define   T_PROC_RET                 DWORD WINAPI
+
+#define   THREAD_MUTEX_T             HANDLE
+#define   NEW_THREAD_MUTEX           CreateMutex (NULL, FALSE, NULL)
+#define   LOCK_THREAD_MUTEX          thread_mutex_lock
+#define   UNLOCK_THREAD_MUTEX(mutex) (! ReleaseMutex ((mutex)))
+
+#define   THREAD_COND_T              CONDITION_VARIABLE
+#define   THREAD_COND_CS_T           CRITICAL_SECTION
+#define   GET_THREAD_COND(c)
+#define   GET_THREAD_COND_CS(c)
+#define   THREAD_COND_ENTER_CS(cs)   EnterCriticalSection ((cs))
+#define   THREAD_COND_LEAVE_CS(cs)   LeaveCriticalSection ((cs))
+#define   SIGNAL_THREAD_COND(cond)   WakeConditionVariable ((cond))
+#define   BCAST_THREAD_COND(cond)    WakeAllConditionVariable ((cond))
+#define   WAIT_THREAD_COND(cond, cs, t) \
+	SleepConditionVariableCS((cond), (cs), t)
+
+#define   THREAD_ATEXIT_BEGIN
+#define   THREAD_ATEXIT_END
+
+typedef T_PROC_RET (*scot_thread_entry_fptr) (void *);
+
+THREAD_T       thread_new        (T_PROC_RET (*)(void *), void*);
+int            thread_join       (THREAD_T, unsigned int);
+THREAD_MUTEX_T thread_mutex_new  (void);
+int            thread_mutex_lock (THREAD_MUTEX_T *);
+
+#endif   /* THREAD_H */

+/*
+ * scot_common.h: commen difinitions for scot.
+ *                scot is a c obliging toolbox.
+ *
+ * Copyright (C) 2006 Georg Steffers. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU Genral Public
+ * License (GPL). Please see gpl.txt for details or refer to 
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * Author: Georg Steffers <georg@steffers.org>
+ *
+ * 01/22/2006: Georg Steffers - introduced to give support for gettext
+ *                              to all code used in san.
+ * 01/24/2006: Georg Steffers - introduce some new macros:
+ *                                  SANTEXTDOMAIN -> textdomain for messages
+ *                                                   given by libsan functions.
+ *                                  LOCALDIR -> directory where to find that
+ *                                              textdomain.
+ *                                  D_(s) ->    translates with the
+ *                                              SANTEXTDOMAIN. This should be
+ *                                              called for strings defined
+ *                                              within san. But remember to
+ *                                              call 
+ *                                              bindtextdomain (
+ *                                                    SANTEXTDOMAIN, LOCALEDIR);
+ *                                              first.
+ */
+#ifndef  SCOT_COMMOM_H
+#define  SCOT_COMMON_H
+
+#include <locale.h>
+#include <libintl.h>
+#include <ctype.h>
+#include <scot/scot_int.h>
+
+/* for PACKAGE and LOCALEDIR */
+#ifdef   HAVE_CONFIG_H
+#include "../config.h"
+#else
+#define  PACKAGE           "scot"
+#define  LOCALEDIR         "/usr/share/locale"
+#endif   /* HAVE_CONFIG_H */
+
+#define  _(string)         gettext(string)   /* our mark for xgettext */
+#define  D_(s)             dgettext(PACKAGE, s)
+                                             /* a mark dgettext calls */
+#define  N_(string)        (string)          /* noop mark for gettext */
+
+/* inline for C++, GCC, C99. For C89 these macros are empty. */
+#if defined(__cplusplus)
+#  define STATIC_INLINE    static inline
+#  define INLINE           inline
+scot/#  define EXTERN_INLINE    inline
+#elif defined(__GNUC__)
+#  define STATIC_INLINE    static __inline__
+#  define INLINE           static __inline__
+#  define EXTERN_INLINE    extern __inline__
+#elif __STDC_VERSION__ >= 199901
+#  define STATIC_INLINE    static inline
+#  define INLINE           static inline
+#  define EXTERN_INLINE    inline
+#else  /* C89 */
+#  define STATIC_INLINE    static
+#  define INLINE           static
+#  define EXTERN_INLINE
+#endif /* inline definitions */
+
+#define SCOT_SOCKET_BACKLOG	5
+
+/*int scot_strisdigit (const char *);*/
+#ifndef SCOT_STRISDIGIT
+#define SCOT_STRISDIGIT   scot_strisdigit
+static
+inline
+int scot_strisdigit (const char * str)
+{
+	while (*str)
+		if (!isdigit (*(str++))) return 0;
+	return 1;
+}
+#endif
+
+#ifndef UNIX_PATH_MAX
+/* 
+ * this should be done better....i got this val from linux/un.h but as
+ * this should be portable i should think about a more portable way to get
+ * this...maybe with configure....
+ */
+#define UNIX_PATH_MAX   108
+#endif /* UNIX_PATH_MAX */
+
+#define SCOT_UNX_PATH_TO_LONG		0
+extern const char * scot_common_errmsg[];
+
+int base2exp (uint32_t);
+
+#endif   /* SCOT_COMMON_H */

+EXTRA_DIST = codeset.m4 gettext.m4 glibc21.m4 iconv.m4 intdiv0.m4 intmax.m4 inttypes.m4 inttypes_h.m4 inttypes-pri.m4 isc-posix.m4 lcmessage.m4 lib-ld.m4 lib-link.m4 lib-prefix.m4 longdouble.m4 longlong.m4 nls.m4 po.m4 printf-posix.m4 progtest.m4 signed.m4 size_max.m4 stdint_h.m4 uintmax_t.m4 ulonglong.m4 wchar_t.m4 wint_t.m4 xsize.m4