removing PDP source (except debian files) before import of PDP 0.12.4

svn path=/trunk/externals/pdp/; revision=4217

19 files changed, 0 insertions, 5578 deletions

diff --git a/system/kernel/CONTENTS b/system/kernel/CONTENTS
deleted file mode 100644
index c2f7c8c..0000000
--- a/system/kernel/CONTENTS
+++ /dev/null
@@ -1,7 +0,0 @@
-debug		debug stuff
-forth		the forth system
-list		the list implementation
-mem		memory allocation stuf
-packet		the packet memory manager
-type		the type handling and conversion system
-symbol		symbol implementation, with namespaces for forth, types, classes, ...
diff --git a/system/kernel/Makefile b/system/kernel/Makefile
deleted file mode 100644
index f1d82a9..0000000
--- a/system/kernel/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-
-OBJECTS = pdp.o pdp_ut.o pdp_packet.o pdp_queue.o pdp_comm.o \
-	pdp_control.o pdp_compat.o pdp_type.o pdp_dpd_command.o \
-	pdp_list.o pdp_forth.o
-
-
-include ../../Makefile.config
-
-all: pdp_main_clean $(OBJECTS)
-
-pdp_main_clean:
-	rm -f pdp.o
-
-clean:
-	rm -f *~
-	rm -f *.o
diff --git a/system/kernel/pdp.c b/system/kernel/pdp.c
deleted file mode 100644
index d71e655..0000000
--- a/system/kernel/pdp.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- *   Pure Data Packet system implementation: setup code
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include "pdp_config.h"
-#include "pdp.h"
-#include <stdio.h>
-
-/* all symbols are C style */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/* module setup declarations (all C-style) */
-
-/* pdp system / internal stuff */
-void pdp_list_setup(void);
-void pdp_sym_setup(void);
-void pdp_forth_setup(void);
-void pdp_type_setup(void);
-void pdp_packet_setup(void);
-void pdp_ut_setup(void);
-void pdp_queue_setup(void);
-void pdp_control_setup(void);
-void pdp_image_setup(void);
-void pdp_bitmap_setup(void);
-void pdp_matrix_setup(void);
-
-
-/* pdp modules */
-void pdp_xv_setup(void);
-void pdp_add_setup(void);
-void pdp_mul_setup(void);
-void pdp_mix_setup(void);
-void pdp_randmix_setup(void);
-void pdp_qt_setup(void);
-void pdp_v4l_setup(void);
-void pdp_reg_setup(void);
-void pdp_conv_setup(void);
-void pdp_bq_setup(void);
-void pdp_del_setup(void);
-void pdp_snap_setup(void);
-void pdp_trigger_setup(void);
-void pdp_route_setup(void);
-void pdp_noise_setup(void);
-void pdp_gain_setup(void);
-void pdp_chrot_setup(void);
-void pdp_scope_setup(void);
-void pdp_scale_setup(void);
-void pdp_zoom_setup(void);
-void pdp_scan_setup(void);
-void pdp_scanxy_setup(void);
-void pdp_sdl_setup(void);
-void pdp_cheby_setup(void);
-void pdp_grey2mask_setup(void);
-void pdp_constant_setup(void);
-void pdp_logic_setup(void);
-void pdp_glx_setup(void);
-void pdp_loop_setup(void);
-void pdp_description_setup(void);
-void pdp_convert_setup(void);
-void pdp_stateless_setup(void);
-void pdp_mat_mul_setup(void);
-void pdp_mat_lu_setup(void);
-void pdp_mat_vec_setup(void);
-void pdp_plasma_setup(void);
-void pdp_cog_setup(void);
-void pdp_histo_setup(void);
-void pdp_array_setup(void);
-
-/* hacks */
-void pdp_inspect_setup(void);
-void pdp_slice_cut_setup(void);
-void pdp_slice_glue_setup(void);
-
-/* testing */
-void pdp_dpd_test_setup(void);
-void pdp_forthproc_setup(void);
-
-
-
-/* library setup routine */
-void pdp_setup(void){
-    
-    /* babble */
-    post ("PDP: pure data packet");
-
-#ifdef PDP_VERSION	
-    fprintf(stderr, "PDP: version " PDP_VERSION "\n");
-#endif
-
-
-    /* setup pdp system */
-    pdp_list_setup();
-    pdp_type_setup();
-    pdp_sym_setup();
-    pdp_packet_setup();
-    pdp_forth_setup();
-    pdp_control_setup();
-
-    pdp_image_setup();
-    pdp_bitmap_setup();
-    pdp_matrix_setup();
-
-    pdp_queue_setup();
-
-    /* setup utility toolkit */
-    pdp_ut_setup();
-
-    /* setup pdp modules*/
-    pdp_add_setup();
-    pdp_mul_setup();
-    pdp_mix_setup();
-    pdp_randmix_setup();
-    pdp_reg_setup();
-    pdp_conv_setup();
-    pdp_bq_setup();
-    pdp_del_setup();
-    pdp_snap_setup();
-    pdp_trigger_setup();
-    pdp_route_setup();
-    pdp_noise_setup();
-    pdp_plasma_setup();
-    pdp_gain_setup();
-    pdp_chrot_setup();
-    pdp_scope_setup();
-    pdp_scale_setup();
-    pdp_zoom_setup();
-    pdp_scan_setup();
-    pdp_scanxy_setup();
-    pdp_cheby_setup();
-    pdp_grey2mask_setup();
-    pdp_constant_setup();
-    pdp_logic_setup();
-    pdp_loop_setup();
-    pdp_description_setup();
-    pdp_convert_setup();
-    pdp_stateless_setup();
-    pdp_mat_mul_setup();
-    pdp_mat_lu_setup();
-    pdp_mat_vec_setup();
-    pdp_cog_setup();
-    pdp_histo_setup();
-    pdp_array_setup();
-
-    /* experimental stuff */
-    pdp_slice_cut_setup();
-    pdp_slice_glue_setup();
-    pdp_inspect_setup();
-
-    /* testing */
-    //pdp_dpd_test_setup();
-    pdp_forthproc_setup();
-
-    /* optional modules */
-
-#ifdef HAVE_PDP_QT
-    pdp_qt_setup();
-#endif
-
-#ifdef HAVE_PDP_XV
-    pdp_xv_setup();
-#endif
-
-#ifdef HAVE_PDP_SDL
-    pdp_sdl_setup();
-#endif
-
-#ifdef HAVE_PDP_V4L
-    pdp_v4l_setup();
-#endif
-
-#ifdef HAVE_PDP_GLX
-    pdp_glx_setup();
-#endif
-
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_comm.c b/system/kernel/pdp_comm.c
deleted file mode 100644
index bcc0e3a..0000000
--- a/system/kernel/pdp_comm.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- *   Pure Data Packet system implementation.
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-/* this file contains misc communication (packet) methods for pd */
-
-
-#include "pdp.h"
-#include "pdp_internals.h"
-#include <stdio.h>
-
-/* all symbols are C style */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-t_symbol *_pdp_sym_pdp;
-t_symbol *_pdp_sym_rro;
-t_symbol *_pdp_sym_rrw;
-t_symbol *_pdp_sym_prc;
-t_symbol *_pdp_sym_dpd;
-t_symbol *_pdp_sym_ins;
-t_symbol *_pdp_sym_acc;
-
-t_symbol *pdp_sym_pdp() {return _pdp_sym_pdp;}
-t_symbol *pdp_sym_rro() {return _pdp_sym_rro;}
-t_symbol *pdp_sym_rrw() {return _pdp_sym_rrw;}
-t_symbol *pdp_sym_prc() {return _pdp_sym_prc;}
-t_symbol *pdp_sym_dpd() {return _pdp_sym_dpd;}
-t_symbol *pdp_sym_ins() {return _pdp_sym_ins;}
-t_symbol *pdp_sym_acc() {return _pdp_sym_acc;}
-
-/************** packet management and communication convenience functions ************/
-
-/* send a packet to an outlet */
-void outlet_pdp(t_outlet *out, int packetid)
-{
-    t_atom atom[2];
-
-    SETFLOAT(atom+1, (float)packetid);
-
-    SETSYMBOL(atom+0, pdp_sym_rro());
-    outlet_anything(out, pdp_sym_pdp(), 2, atom);
-
-    SETSYMBOL(atom+0, pdp_sym_rrw());
-    outlet_anything(out, pdp_sym_pdp(), 2, atom);
-
-    SETSYMBOL(atom+0, pdp_sym_prc());
-    outlet_anything(out, pdp_sym_pdp(), 2, atom);
-
-}
-
-/* send an accumulation packet to an outlet */
-void outlet_dpd(t_outlet *out, int packetid)
-{
-    t_atom atom[2];
-
-    SETFLOAT(atom+1, (float)packetid);
-
-    SETSYMBOL(atom+0, pdp_sym_ins());
-    outlet_anything(out, pdp_sym_dpd(), 2, atom);
-
-    SETSYMBOL(atom+0, pdp_sym_acc());
-    outlet_anything(out, pdp_sym_dpd(), 2, atom);
-
-}
-
-/* unregister a packet and send it to an outlet */
-void
-
-pdp_packet_pass_if_valid(t_outlet *outlet, int *packet_ptr)
-{
-    t_pdp *header = pdp_packet_header(*packet_ptr);
-    //if (-1 != *packet){
-    if (header){
-	/* if packet is exclusively owned, mark as passing */
-	if (1 == header->users)  pdp_packet_mark_passing(packet_ptr);
-
-	/* send */
-	outlet_pdp(outlet, *packet_ptr);
-
-	/* if the packet is still here (was passing and not registered, 
-	   or it was a shared copy): unregister it */
-	if (-1 != *packet_ptr){
-	    pdp_packet_unmark_passing(*packet_ptr);
-	    pdp_packet_mark_unused(*packet_ptr);
-	    *packet_ptr = -1;
-	}
-    }
-}
-
-void
-pdp_packet_replace_if_valid(int *dpacket, int *spacket)
-{
-    if (-1 != *spacket){
-	pdp_packet_mark_unused(*dpacket);
-	*dpacket = *spacket;
-	*spacket = -1;
-    }
-    
-}
-
-
-int
-pdp_packet_copy_ro_or_drop(int *dpacket, int spacket)
-{
-    int drop = 0;
-    if (*dpacket == -1) *dpacket = pdp_packet_copy_ro(spacket);
-    else {
-	/* send a notification there is a dropped packet */
-	pdp_control_notify_drop(spacket);
-	drop = 1;
-    }
-    return drop;
-}
-
-
-int
-pdp_packet_copy_rw_or_drop(int *dpacket, int spacket)
-{
-    int drop = 0;
-    if (*dpacket == -1) *dpacket = pdp_packet_copy_rw(spacket);
-    else {
-	/* send a notification there is a dropped packet */
-	pdp_control_notify_drop(spacket);
-	drop = 1;
-    }
-    return drop;
-}
-
-int
-pdp_packet_convert_ro_or_drop(int *dpacket, int spacket, t_pdp_symbol *template)
-{
-    int drop = 0;
-
-    if (!template) return pdp_packet_copy_ro_or_drop(dpacket, spacket);
-
-    if (*dpacket == -1) *dpacket = pdp_packet_convert_ro(spacket, template);
-    else {
-	/* send a notification there is a dropped packet */
-	pdp_control_notify_drop(spacket);
-	drop = 1;
-    }
-    return drop;
-}
-
-
-int
-pdp_packet_convert_rw_or_drop(int *dpacket, int spacket, t_pdp_symbol *template)
-{
-    int drop = 0;
-
-    if (!template) return pdp_packet_copy_rw_or_drop(dpacket, spacket);
-
-    if (*dpacket == -1) *dpacket = pdp_packet_convert_rw(spacket, template);
-    else {
-	/* send a notification there is a dropped packet */
-	pdp_control_notify_drop(spacket);
-	drop = 1;
-    }
-    return drop;
-}
-
-
-void
-pdp_sym_setup(void)
-{
-    _pdp_sym_pdp = gensym("pdp");
-    _pdp_sym_rro = gensym("register_ro");
-    _pdp_sym_rrw = gensym("register_rw");
-    _pdp_sym_prc = gensym("process");
-    _pdp_sym_dpd = gensym("dpd");
-    _pdp_sym_ins = gensym("inspect");
-    _pdp_sym_acc = gensym("accumulate");
-}
-
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_compat.c b/system/kernel/pdp_compat.c
deleted file mode 100644
index 4bcf00d..0000000
--- a/system/kernel/pdp_compat.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- *   Pure Data Packet system implementation. Compatibility routines.
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-/* this file contains misc communication methods */
-
-
-#include "pdp.h"
-#include "pdp_internals.h"
-#include <stdio.h>
-
-/* all symbols are C style */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-
-void
-pdp_pass_if_valid(t_outlet *outlet, int *packet)
-{
-    pdp_packet_pass_if_valid(outlet, packet);
-}
-
-void
-pdp_replace_if_valid(int *dpacket, int *spacket)
-{
-    pdp_packet_replace_if_valid(dpacket, spacket);
-    
-}
-
-
-
-
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_control.c b/system/kernel/pdp_control.c
deleted file mode 100644
index 2cba7b7..0000000
--- a/system/kernel/pdp_control.c
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- *   Pure Data Packet system implementation: control object
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-/* this is an actual pd class that is used for communication with the
-   pdp framework */
-
-#include "pdp.h"
-#include "pdp_internals.h"
-#include "pdp_control.h"
-#include <stdio.h>
-
-/* all symbols are C style */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-
-static long dropped_packets;
-
-static t_class* pdp_control_class;
-
-
-/* pdp control instance data */
-
-struct _pdp_control;
-typedef struct _pdp_control
-{
-    t_object x_obj;
-    t_outlet *x_outlet0;
-    struct _pdp_control *x_next;
-
-} t_pdp_control;
-
-
-
-static t_pdp_control *pdp_control_list;
-
-static void pdp_control_info(t_pdp_control *x)
-{
-}
-
-static void pdp_control_collectgarbage(t_pdp_control *x)
-{
-    int nb_packets_freed =  pdp_pool_collect_garbage();
-    post("pdp_control: freed %d packets", nb_packets_freed);
-    
-}
-
-static void pdp_control_set_mem_limit(t_pdp_control *x, t_floatarg f)
-{
-    int limit = (int)f;
-    if (limit < 0) limit = 0;
-    pdp_pool_set_max_mem_usage(limit);
-    if (limit) post("pdp_control: set memory limit to %d bytes", limit);
-    else post("pdp_control: disabled memory limit");
-    
-}
-
-static void pdp_control_thread(t_pdp_control *x, t_floatarg f)
-{
-    int t = (int)f;
-
-    if (t){
-	post("pdp_control: pdp is now using its own processing thread");
-	pdp_queue_use_thread(1);
-    }
-    else {
-	post("pdp_control: pdp is now using the main pd thread");
-	pdp_queue_use_thread(0);
-    }
-}
-
-
-static void pdp_control_send_drop_message(t_pdp_control *x)
-{
-    t_atom atom[1];
-    t_symbol *s = gensym("pdp_drop");
-
-    SETFLOAT(atom+0, (float)dropped_packets);
-    outlet_anything(x->x_outlet0, s, 1, atom);
-}
-
-
-static void pdp_control_free(t_pdp_control *x)
-{
-    /* remove from linked list */
-    t_pdp_control *curr = pdp_control_list;
-    if (pdp_control_list == x) pdp_control_list = x->x_next;
-    else while (curr){
-	if (curr->x_next == x) {
-	    curr->x_next = x->x_next;
-	    break;
-	}
-	else {
-	    curr = curr->x_next;
-	}
-	
-    }
-}
-
-
-static void *pdp_control_new(void)
-{
-    t_pdp_control *x = (t_pdp_control *)pd_new(pdp_control_class);
-    x->x_outlet0 = outlet_new(&x->x_obj, &s_anything);
-
-    /* add to list */
-    x->x_next = pdp_control_list;
-    pdp_control_list = x;
-    return x;
-}
-
-/************************* class methods ***************************************/
-
-
-void pdp_control_addmethod(t_method m, t_symbol *s)
-{
-    class_addmethod(pdp_control_class, m, s, A_GIMME, A_NULL);
-}
-
-void pdp_control_setup(void)
-{
-
-    pdp_control_list = 0;
-    dropped_packets = 0;
-
-    /* setup pd class data */
-    pdp_control_class = class_new(gensym("pdp_control"), (t_newmethod)pdp_control_new,
-    	(t_method)pdp_control_free, sizeof(t_pdp_control), 0, A_NULL);
-
-
-    class_addmethod(pdp_control_class, (t_method)pdp_control_info, gensym("info"), A_NULL);   
-    class_addmethod(pdp_control_class, (t_method)pdp_control_thread, gensym("thread"),  A_DEFFLOAT, A_NULL);   
-    class_addmethod(pdp_control_class, (t_method)pdp_control_collectgarbage, gensym("collectgarbage"),  A_NULL);   
-    class_addmethod(pdp_control_class, (t_method)pdp_control_set_mem_limit, gensym("memlimit"),  A_FLOAT, A_NULL);   
-}
-
-
-
-void pdp_control_notify_broadcast(t_pdp_control_method_notify *notify)
-{
-    t_pdp_control *curr = pdp_control_list;
-    while (curr){
-	(*notify)(curr);
-	curr = curr->x_next;
-    }
-}
-
-
-
-/************************* notify class methods  *************************/
-
-void pdp_control_notify_drop(int packet)
-{
-    dropped_packets++;
-
-    /* send drop notify to controller class instances */
-    pdp_control_notify_broadcast(pdp_control_send_drop_message);
-    //post("dropped packet");
-}
-
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_debug.c b/system/kernel/pdp_debug.c
deleted file mode 100644
index 07f6541..0000000
--- a/system/kernel/pdp_debug.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <sys/types.h>
-#include <signal.h>
-#include <unistd.h>
-#include "pdp_post.h"
-
-int pdp_debug_sigtrap_on_assert;
-
-
-void pdp_assert_hook (char *condition, char *file, int line)
-{
-    pdp_post("PDP_ASSERT (%s) failed in file %s, line %u. ", condition, file, line);
-    pdp_post("%s.\n", pdp_debug_sigtrap_on_assert ? "sending SIGTRAP" : "continuing");
-
-    if (pdp_debug_sigtrap_on_assert) kill(getpid(), SIGTRAP);
-}
-
-
-void pdp_debug_setup(void)
-{
-    pdp_debug_sigtrap_on_assert = 1;
-}
diff --git a/system/kernel/pdp_dpd_command.c b/system/kernel/pdp_dpd_command.c
deleted file mode 100644
index 0d3ecf1..0000000
--- a/system/kernel/pdp_dpd_command.c
+++ /dev/null
@@ -1,87 +0,0 @@
-
-/*
- *   Pure Data Packet header file. DPD command class
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-/* this object implements a dpd command queue and command object */
-
-#include "pdp.h"
-#include "pdp_dpd_command.h"
-
-void pdp_dpd_commandfactory_init(t_pdp_dpd_commandfactory *x, u32 size)
-{
-    x->nb_commands = 0;
-    x->command_size = size;
-    x->command = 0;
-}
-
-void _pdp_dpd_commandfactory_free(t_pdp_dpd_command *x)
-{
-    if (x) _pdp_dpd_commandfactory_free(x->next);
-    pdp_dealloc(x);
-}
-
-void pdp_dpd_commandfactory_free(t_pdp_dpd_commandfactory *x)
-{
-    _pdp_dpd_commandfactory_free(x->command);
-    x->command = 0;
-    x->nb_commands = 0;
-}
-
-
-/* factory method */
-t_pdp_dpd_command *pdp_dpd_commandfactory_get_new_command(t_pdp_dpd_commandfactory *x)
-{
-
-    t_pdp_dpd_command *c = x->command;
-    t_pdp_dpd_command *oldhead = c;
-
-    /* check if we can reuse */
-    while (c){
-	if (!c->used){
-	    c->used = 1;
-	    //post("reusing command %x", c, c->used);
-	    return c;
-	}
-	//post("command %x is used %d", c, c->used);
-	c = c->next;
-    }
-
-    /* create a new command */
-    x->command = (t_pdp_dpd_command *)pdp_alloc(x->command_size);
-    x->command->next = oldhead;
-    x->command->used = 1;
-    x->nb_commands++;
-    //post("created command %x, nbcommands: %d", x->command, x->nb_commands);
-    return x->command;
-
-}
-
-
-/* (self)destructor */
-void pdp_dpd_command_suicide(void *x)
-{
-    t_pdp_dpd_command *c = (t_pdp_dpd_command *)x;
-    c->used = 0;
-    //post("command %x committed suicide %d", c, c->used);
-}
-
-
-
-
diff --git a/system/kernel/pdp_forth.c b/system/kernel/pdp_forth.c
deleted file mode 100644
index 1764004..0000000
--- a/system/kernel/pdp_forth.c
+++ /dev/null
@@ -1,541 +0,0 @@
-/*
- *   Pure Data Packet header file. Packet processor system
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <stdlib.h>
-#include <math.h>
-#include "pdp.h"
-#include "pdp_forth.h"
-
-#define D if (0)
-
-
-
-t_pdp_stack *pdp_stack_new(void) {return pdp_list_new(0);}
-
-void pdp_stack_free(t_pdp_stack *s) {
-    pdp_tree_strip_packets(s);
-    pdp_list_free(s);
-}
-
-
-/* some stack manips */
-t_pdp_word_error pdp_stack_dup(t_pdp_stack *s)
-{
-    if (!s->first) return e_underflow;
-    pdp_list_add(s, s->first->t, s->first->w);
-
-    /* copy it properly if its a packet */
-    if (s->first->t == a_packet){
-	s->first->w.w_packet = pdp_packet_copy_ro(s->first->w.w_packet);
-    }
-    return e_ok;
-}
-
-t_pdp_word_error pdp_stack_drop(t_pdp_stack *s)
-{
-    if (!s->first) return e_underflow;
-
-    /* delete it properly if its a packet */
-    if (s->first->t == a_packet){
-	pdp_packet_mark_unused(s->first->w.w_packet);
-    }
-    pdp_list_pop(s);
-
-    return e_ok;
-}
-
-t_pdp_word_error pdp_stack_over(t_pdp_stack *s)
-{
-    if (s->elements < 2) return e_underflow;
-    pdp_list_add(s, s->first->next->t, s->first->next->w);
-
-    /* copy it properly if its a packet */
-    if (s->first->t == a_packet){
-	s->first->w.w_packet = pdp_packet_copy_ro(s->first->w.w_packet);
-    }
-    
-    return e_ok;
-}
-
-t_pdp_word_error pdp_stack_swap(t_pdp_stack *s)
-{
-    t_pdp_word w;
-    t_pdp_word_type t;
-    if (s->elements < 2) return e_underflow;
-    w = s->first->w;
-    t = s->first->t;
-    s->first->w = s->first->next->w;
-    s->first->t = s->first->next->t;
-    s->first->next->w = w;
-    s->first->next->t = t;
-    return e_ok;
-    
-}
-
-/* pushing and popping the stack */
-
-t_pdp_word_error pdp_stack_push_float(t_pdp_stack *s,  float f)         {pdp_list_add(s, a_float,   (t_pdp_word)f); return e_ok;}
-t_pdp_word_error pdp_stack_push_int(t_pdp_stack *s,    int i)           {pdp_list_add(s, a_int,     (t_pdp_word)i); return e_ok;}
-t_pdp_word_error pdp_stack_push_pointer(t_pdp_stack *s,    void *x)     {pdp_list_add(s, a_pointer, (t_pdp_word)x); return e_ok;}
-t_pdp_word_error pdp_stack_push_symbol(t_pdp_stack *s, t_pdp_symbol *x) {pdp_list_add(s, a_symbol,  (t_pdp_word)x); return e_ok;}
-
-/* note: packets pushed stack are owned by the stack. if a caller wants to keep a packet that
-   will be deleted by the word, it should make a copy before transferring it to the stack.
-   if a stack processor wants to write to a packet, it should replace it with a writable copy first */
-
-t_pdp_word_error pdp_stack_push_packet(t_pdp_stack *s, int p)           {pdp_list_add(s, a_packet, (t_pdp_word)p); return e_ok;}
-
-
-
-
-
-t_pdp_word_error pdp_stack_pop_float(t_pdp_stack *s, float *f)
-{
-    if (!s->first) return e_underflow;
-
-    if (s->first->t == a_float) *f = s->first->w.w_float; 
-    else if (s->first->t == a_int) *f = (float)s->first->w.w_int; 
-    else *f = 0.0f;
-    pdp_stack_drop(s);
-    return e_ok;
-}
-
-t_pdp_word_error pdp_stack_pop_int(t_pdp_stack *s, int *i)
-{
-    if (!s->first) return e_underflow;
-    if (s->first->t == a_int) *i = s->first->w.w_int; 
-    else if (s->first->t == a_float) *i = (int)s->first->w.w_float; 
-    else *i = 0;
-    pdp_stack_drop(s);
-    return e_ok;
-}
-
-t_pdp_word_error pdp_stack_pop_pointer(t_pdp_stack *s, void **x)
-{
-    if (!s->first) return e_underflow;
-    *x = (s->first->t == a_pointer) ? s->first->w.w_pointer : 0; 
-    pdp_stack_drop(s);
-    return e_ok;
-}
-
-t_pdp_word_error pdp_stack_pop_symbol(t_pdp_stack *s, t_pdp_symbol **x)
-{
-    if (!s->first) return e_underflow;
-    *x = (s->first->t == a_symbol) ? s->first->w.w_symbol : pdp_gensym("invalid"); 
-    pdp_stack_drop(s);
-    return e_ok;
-}
-
-/* packets popped from the stack are owned by the caller */
-
-t_pdp_word_error pdp_stack_pop_packet(t_pdp_stack *s, int *p)
-{
-    if (!s->first) return e_underflow;
-    *p = (s->first->t == a_packet) ? s->first->w.w_packet : -1; 
-    pdp_list_pop(s); //ownership is transferred to receiver, drop kills the packet
-    return e_ok;
-}
-
-
-t_pdp_word_error pdp_stack_mov(t_pdp_stack *s)
-{
-    int position;
-    t_pdp_atom *a, *a_before;
-    if (s->elements < 2) return e_underflow;
-    if (s->first->t != a_int) return e_type;
-
-    pdp_stack_pop_int(s, &position); // get insert point
-    if (position < 1) return e_ok; // < 0 : invalid; do nothing, 0 : nop (= insert at start, but already at start)
-    if ((s->elements-1) < position) return e_underflow;
-
-    a = s->first; // get first atom
-    s->first = a->next;
-
-    if (s->elements-1 == position){ //insert at end
-	s->last->next = a;
-	a->next = 0;
-	s->last = a;
-    }
-    else { //insert somewhere in the middle
-	a_before = s->first;
-	while (--position) a_before = a_before->next;
-	a->next = a_before->next;
-	a_before->next = a;
-    }
-    return e_ok;
-}
-
-/* rotate stack down (tos -> bottom) */
-t_pdp_word_error pdp_stack_rdown(t_pdp_stack *s)
-{
-    t_pdp_word_type t = s->first->t;
-    t_pdp_word w = s->first->w;
-    pdp_list_pop(s);
-    pdp_list_add_back(s, t, w);
-    return e_ok;
-}
-
-
-/* convert to int */
-t_pdp_word_error pdp_stack_int(t_pdp_stack *s)
-{
-    int i;
-    pdp_stack_pop_int(s, &i);
-    pdp_stack_push_int(s, i);
-    return e_ok;
-}
-
-/* convert to float */
-t_pdp_word_error pdp_stack_float(t_pdp_stack *s)
-{
-    float f;
-    pdp_stack_pop_float(s, &f);
-    pdp_stack_push_float(s, f);
-    return e_ok;
-}
-
-
-#define OP1(name, type, op)					\
-t_pdp_word_error pdp_stack_##name##_##type (t_pdp_stack *s)	\
-{								\
-    type x0;							\
-    pdp_stack_pop_##type (s, &(x0));				\
-    pdp_stack_push_##type (s, op (x0));				\
-    return e_ok;						\
-}
-
-#define OP2(name, type, op)					\
-t_pdp_word_error pdp_stack_##name##_##type (t_pdp_stack *s)	\
-{								\
-    type x0, x1;						\
-    pdp_stack_pop_##type (s, &(x0));				\
-    pdp_stack_pop_##type (s, &(x1));				\
-    pdp_stack_push_##type (s, x1 op x0);			\
-    return e_ok;						\
-}
-
-/* some floating point and integer stuff */
-
-OP2(add, float, +);
-OP2(sub, float, -);
-OP2(mul, float, *);
-OP2(div, float, /);
-
-OP1(sin, float, sin);
-OP1(cos, float, cos);
-
-OP2(add, int, +);
-OP2(sub, int, -);
-OP2(mul, int, *);
-OP2(div, int, /);
-OP2(mod, int, %);
-
-OP2(and, int, &);
-OP2(or, int, |);
-OP2(xor, int, ^);
-
-
-/* some integer stuff */
-
-t_pdp_word_error pdp_stack_push_invalid_packet(t_pdp_stack *s)
-{
-    pdp_stack_push_packet(s, -1);
-    return e_ok;
-}
-
-/* dictionary manipulation */
-
-void pdp_forth_word_print_debug(t_pdp_symbol *s)
-{
-    t_pdp_atom *a;
-    if (!s->s_word_spec){
-	post("%s is not a forth word", s->s_name);
-    }
-    else{
-	post("");
-	post("forth word %s", s->s_name);
-	post("\tinput: %d", s->s_word_spec->input_size);
-	post("\toutput: %d", s->s_word_spec->output_size);
-	post("\ttype index: %d", s->s_word_spec->type_index);
-
-	post("\nimplementations:");
-	for(a=s->s_word_spec->implementations->first; a; a=a->next){
-	    t_pdp_forthword_imp *i = a->w.w_pointer;
-	    startpost("\t%s\t", i->type ? i->type->s_name : "anything");
-	    pdp_list_print(i->def);
-	    
-	}
-	post("");
-    }
-}
-
-/* add a definition (list of high level words (symbols) or primitive routines) */
-void pdp_forthdict_add_word(t_pdp_symbol *name, t_pdp_list *def, int input_size, int output_size,
-			    int type_index, t_pdp_symbol *type)
-{
-    t_pdp_forthword_spec *spec = 0;
-    t_pdp_forthword_imp *imp = 0;
-    t_pdp_forthword_imp *old_imp = 0;
-    t_pdp_atom *a;
-    /* check if the word complies to a previously defined word spec with the same name */
-    if (spec = name->s_word_spec){
-	if ((spec->input_size != input_size)
-	    ||(spec->output_size != output_size)
-	    ||(spec->type_index != type_index)){
-	    post("ERROR: pdp_forthdict_add_word: new implementation of [%s] does not comply to old spec",
-		 name->s_name);
-	    return;
-	}
-
-    }
-    /* no previous word spec with this name, so create a new spec */
-    else{
-	spec = name->s_word_spec = (t_pdp_forthword_spec *)pdp_alloc(sizeof(t_pdp_forthword_spec));
-	spec->name = name;
-	spec->input_size = input_size;
-	spec->output_size = output_size;
-	spec->type_index = type_index;
-	spec->implementations = pdp_list_new(0);
-    }
-	
-    /* create the new implementation and add it */
-    imp = (t_pdp_forthword_imp *)pdp_alloc(sizeof(t_pdp_forthword_imp));
-    imp->name = name;
-    imp->def = def;
-    imp->type = type;
-
-    /* can't delete old implemetations because of thread safety */
-    pdp_list_add_pointer(spec->implementations, imp);
-	
-}
-
-/* add a primitive */
-void pdp_forthdict_add_primitive(t_pdp_symbol *name, t_pdp_forthword w, int input_size, int output_size,
-				 int type_index, t_pdp_symbol *type)
-{
-    t_pdp_list *def = pdp_list_new(1);
-    def->first->t = a_pointer;
-    def->first->w.w_pointer = w;
-    pdp_forthdict_add_word(name, def, input_size, output_size, type_index, type);
-}
-
-/* parse a new definition from a null terminated string */
-t_pdp_list *pdp_forth_compile_def(char *chardef)
-{
-    t_pdp_list *l;
-    char *c;
-
-    if (!(l = pdp_list_from_cstring(chardef, &c))){
-	post ("ERROR: pdp_forth_compile_def: parse error parsing: %s", chardef);
-	if (*c) post ("ERROR: remaining input: %s", c);
-    }
-    if (*c){
-	post ("WARNING: pdp_forth_compile_def: parsing: %s", chardef);
-	if (*c) post ("garbage at end of string: %s", c);
-    }
-
-    return l;
-
-}
-
-void pdp_forthdict_compile_word(t_pdp_symbol *name, char *chardef, int input_size, int output_size,
-				int type_index, t_pdp_symbol *type)
-{
-    /* add the definition list to the dictionary */
-    t_pdp_list *def;
-
-    if (def = pdp_forth_compile_def (chardef))
-	pdp_forthdict_add_word(name, def, input_size, output_size, type_index, type);
-    
-    
-}
-
-
-
-/* execute a definition list
-   a def list is a list of primitives, immediates or symbolic words */
-t_pdp_word_error pdp_forth_execute_def(t_pdp_stack *stack, t_pdp_list *def)
-{
-    t_pdp_atom *a;
-    t_pdp_word_error e;
-    t_pdp_forthword w;
-    float f;
-    int i,p;
-    
-    D post("pdp_forth_execute_def %x %x", stack, def);
-    D pdp_list_print(def);
-
-    for (a = def->first; a; a=a->next){
-	switch(a->t){
-	case a_float: // an immidiate float
-            f = a->w.w_float;
-	    D post("pushing %f onto the stack", f);
-	    pdp_stack_push_float(stack, f);
-	    break;
-	case a_int:  // an immidiate int
-            i = a->w.w_int;
-	    D post("pushing %d onto the stack", i);
-	    pdp_stack_push_int(stack, i);
-	    break;
-	case a_packet:  // an immidiate int
-            p = a->w.w_packet;
-	    D post("pushing packet %d onto the stack", p);
-	    pdp_stack_push_packet(stack, pdp_packet_copy_ro(p));
-	    break;
-	case a_symbol:  // a high level word or an immediate symbol
-	    D post("interpeting symbol %s", a->w.w_symbol->s_name);
-	    if (e = pdp_forth_execute_word(stack, a->w.w_symbol)) return e;
-	    break;
-	case a_pointer: // a primitive
-	    w = a->w.w_pointer;
-	    D post("exec primitive %x", w);
-	    if (e = (w(stack))) return e;
-	    break;
-	default:
-	    return e_internal;
-
-	}
-    }
-    return e_ok;
-}
-
-/* execute a symbol (a high level word or an immediate) 
-   this routine does the type based word multiplexing and stack checking */
-t_pdp_word_error pdp_forth_execute_word(t_pdp_stack *stack, t_pdp_symbol *word)
-{
-    t_pdp_symbol *type = 0;
-    t_pdp_atom *a;
-    t_pdp_forthword_spec *spec;
-    t_pdp_forthword_imp *imp = 0;
-    int i;
-
-    D post("pdp_forth_execute_word %x %x", stack, word);
-
-    /* first check if the word is defined. if not, the symbol will be loaded
-       onto the stack as an immidiate symbol */
-
-    if (!(spec = word->s_word_spec)){
-	D post ("pushing symbol %s on the stack", word->s_name);
-	pdp_stack_push_symbol(stack, word);
-	return e_ok;
-    }
-
-    D post("exec high level word [%s]", word->s_name);
-
-    /* it is a word. check the stack size */
-    if (stack->elements < spec->input_size){
-	D post ("error executing [%s]: stack underflow", word->s_name);
-	return e_underflow;
-    }
-
-    /* if the word is type oblivious, symply execute the first (only)
-       implementation in the list */
-    if (spec->type_index < 0){
-	D post("exec type oblivious word [%s]", word->s_name);
-	imp = spec->implementations->first->w.w_pointer;
-	return pdp_forth_execute_def(stack , imp->def);
-    }
-
-    /* if it is not type oblivious, find the type template
-       to determine the correct implementation */
-
-    for(i=spec->type_index,a=stack->first; i--; a=a->next);
-    switch (a->t){
-      /* get type description from first item on*/
-    case a_packet: 
-	type = pdp_packet_get_description(a->w.w_packet); break;
-    case a_symbol:
-	type = a->w.w_symbol; break;
-    case a_float:
-	type = pdp_gensym("float"); break;
-    case a_int:
-	type = pdp_gensym("int"); break;
-    case a_pointer:
-	type = pdp_gensym("pointer"); break;
-    default:
-      /* no type description found on top of stack. */
-        type = pdp_gensym("unknown");
-	break;
-    }
-
-    /* scan the implementation list until a definition with matching type is found
-       if the type spec for a word is NULL, it counts as a match (for generic words) */
-    for (a = spec->implementations->first; a; a = a->next){
-	imp = a->w.w_pointer;
-	if ((!imp->type) || pdp_type_description_match(type, imp->type)){
-	    return pdp_forth_execute_def(stack , imp->def);
-	}
-    }
-    D post("ERROR: pdp_forth_execute_word: type error executing [%s] (2). stack:",word->s_name);
-    D pdp_list_print(stack);
-
-    return e_type; // type error
-    
-}
-
-
-static void _add_2op(char *name, t_pdp_forthword w, char *type){
-    pdp_forthdict_add_primitive(pdp_gensym(name), w, 2, 1, 0, pdp_gensym(type));
-}
-
-static void _add_1op(char *name, t_pdp_forthword w, char *type){
-    pdp_forthdict_add_primitive(pdp_gensym(name), w, 1, 1, 0, pdp_gensym(type));
-}
-
-
-void pdp_forth_setup(void)
-{
-
-    /* add type oblivious (type_index = -1, type = NULL) stack manip primitives */
-    pdp_forthdict_add_primitive(pdp_gensym("dup"),    (t_pdp_forthword)pdp_stack_dup,    1, 2, -1, 0);
-    pdp_forthdict_add_primitive(pdp_gensym("swap"),   (t_pdp_forthword)pdp_stack_swap,   2, 2, -1, 0);
-    pdp_forthdict_add_primitive(pdp_gensym("drop"),   (t_pdp_forthword)pdp_stack_drop,   1, 0, -1, 0);
-    pdp_forthdict_add_primitive(pdp_gensym("over"),   (t_pdp_forthword)pdp_stack_over,   2, 3, -1, 0);
-    pdp_forthdict_add_primitive(pdp_gensym("mov"),    (t_pdp_forthword)pdp_stack_mov,    2, 1, -1, 0);
-    pdp_forthdict_add_primitive(pdp_gensym("down"),  (t_pdp_forthword)pdp_stack_rdown,  1, 1, -1, 0);
-
-    /* type converters (casts) */
-    pdp_forthdict_add_primitive(pdp_gensym("int"),  (t_pdp_forthword)pdp_stack_int,  1, 1, -1, 0);
-    pdp_forthdict_add_primitive(pdp_gensym("float"),  (t_pdp_forthword)pdp_stack_float,  1, 1, -1, 0);
-
-    /* add floating point ops */
-    _add_2op("add", (t_pdp_forthword)pdp_stack_add_float, "float");
-    _add_2op("sub", (t_pdp_forthword)pdp_stack_sub_float, "float");
-    _add_2op("mul", (t_pdp_forthword)pdp_stack_mul_float, "float");
-    _add_2op("div", (t_pdp_forthword)pdp_stack_div_float, "float");
-
-    _add_1op("sin", (t_pdp_forthword)pdp_stack_sin_float, "float");
-    _add_1op("cos", (t_pdp_forthword)pdp_stack_cos_float, "float");
-
-    /* add integer ops */
-    _add_2op("add", (t_pdp_forthword)pdp_stack_add_int, "int");
-    _add_2op("sub", (t_pdp_forthword)pdp_stack_sub_int, "int");
-    _add_2op("mul", (t_pdp_forthword)pdp_stack_mul_int, "int");
-    _add_2op("div", (t_pdp_forthword)pdp_stack_div_int, "int");
-    _add_2op("mod", (t_pdp_forthword)pdp_stack_mod_int, "int");
-
-    _add_2op("and", (t_pdp_forthword)pdp_stack_and_int, "int");
-    _add_2op("or", (t_pdp_forthword)pdp_stack_or_int, "int");
-    _add_2op("xor", (t_pdp_forthword)pdp_stack_xor_int, "int");
-
-    /* some immidiates */
-    pdp_forthdict_add_primitive(pdp_gensym("ip"),  (t_pdp_forthword)pdp_stack_push_invalid_packet,  0, 1, -1, 0);
-    
-}
diff --git a/system/kernel/pdp_list.c b/system/kernel/pdp_list.c
deleted file mode 100644
index ed2ad76..0000000
--- a/system/kernel/pdp_list.c
+++ /dev/null
@@ -1,663 +0,0 @@
-
-/*
- *   Pure Data Packet header file. List class
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-/* who can live without a list, hmm? */
-
-/* rethink the list of list thing:
-   should free and copy really copy the lists, or should
-   references to lists be allowed too?
-
-   maybe references to lists as generic pointers? */
-
-#include "pdp_list.h"
-#include "pdp_types.h"
-#include "pdp.h"
-#include <pthread.h>
-#include <stdlib.h>
-
-#define D if (0)
-
-#define PDP_LIST_BLOCKSIZE 4096
-
-#define PDP_ATOM_ALLOC _pdp_atom_reuse
-#define PDP_ATOM_DEALLOC _pdp_atom_save
-//#define PDP_ATOM_ALLOC _pdp_atom_alloc
-//#define PDP_ATOM_DEALLOC _pdp_atom_dealloc
-
-static t_pdp_atom *freelist;
-static t_pdp_list *blocklist;
-static pthread_mutex_t mut;
-
-/* memory allocation (for ease of wrapping) */
-static inline t_pdp_list* _pdp_list_alloc(void){return (t_pdp_list *)pdp_alloc(sizeof(t_pdp_list));}
-static inline void _pdp_list_dealloc(t_pdp_list *list){pdp_dealloc(list);}
-static inline t_pdp_atom* _pdp_atom_alloc(void){return (t_pdp_atom *)pdp_alloc(sizeof(t_pdp_atom));}
-static inline void _pdp_atom_dealloc(t_pdp_atom *a){pdp_dealloc(a);}
-
-
-
-/* some private helper methods */
-
-/* list pool setup */
-void pdp_list_setup(void)
-{
-    freelist = 0;
-    blocklist = _pdp_list_alloc();
-    blocklist->elements = 0;
-    blocklist->first = 0;
-    pthread_mutex_init(&mut, NULL);
-
-#if 0
-    {
-	char *c = "(test 1 2 (23 4)) (een (zes (ze)ven ()))) (())";
-	while (*c){
-	    t_pdp_list *l = pdp_list_from_char(c, &c);
-	    if (l) pdp_list_print(l); 
-	    else{
-		post("parse error: remaining input: %s", c); break;
-	    }
-	}
-    }
-#endif
-
-}
-
-/* allocate a block */
-static t_pdp_atom* _pdp_atom_block_alloc(int size)
-{
-    int i = size;
-    t_pdp_atom *atom_block, *atom;
-    atom_block = (t_pdp_atom *)pdp_alloc(sizeof(t_pdp_atom) * size);
-    atom = atom_block;
-    while(i--){
-        atom->next = atom + 1;
-        atom->t = a_undef;
-	atom->w.w_int = 0;
-        atom++;
-    }
-    atom_block[size-1].next = 0;
-    return atom_block;
-}
-
-static void _pdp_atomlist_fprint(FILE* f, t_pdp_atom *a);
-
-static void _pdp_atom_refill_freelist(void)
-{
-    t_pdp_atom *atom;
-
-    if (freelist != 0) post("ERROR:_pdp_atom_do_reuse: freelist != 0");
-
-    /* get a new block */
-    freelist = _pdp_atom_block_alloc(PDP_LIST_BLOCKSIZE);
-    //post("new block");
-    //_pdp_atomlist_fprint(stderr, freelist);
-
-    /* take the first element from the block to serve as a blocklist element */
-    atom = freelist;
-    atom->t = a_pointer;
-    atom->w.w_pointer = freelist;
-    freelist = freelist->next;
-    atom->next = blocklist->first;
-    blocklist->first = atom;
-    blocklist->elements++;
-    
-}
-
-
-/* reuse an old element from the freelist, or allocate a new block */
-static inline t_pdp_atom* _pdp_atom_reuse(void)
-{
-    t_pdp_atom *atom;
-
-    pthread_mutex_lock(&mut);
-
-    while (!(atom = freelist)){
-	_pdp_atom_refill_freelist();
-    }
-    /* delete the element from the freelist */
-    freelist = freelist->next;
-    atom->next = 0;
-
-    pthread_mutex_unlock(&mut);
-
-    return atom;
-}
-
-static inline void _pdp_atom_save(t_pdp_atom *atom)
-{
-    pthread_mutex_lock(&mut);
-
-    atom->next = freelist;
-    freelist = atom;
-
-    pthread_mutex_unlock(&mut);
-}
-
-
-
-
-
-
-/* create a list */
-t_pdp_list* pdp_list_new(int elements)
-{
-    t_pdp_atom *a = 0;
-    t_pdp_list *l = _pdp_list_alloc();
-    l->elements = 0;
-    if (elements){
-	a = PDP_ATOM_ALLOC();
-	l->elements++;
-	a->t = a_undef;
-	a->w.w_int = 0;
-	a->next = 0;
-	elements--;
-    }
-    l->first = a;
-    l->last = a;
-
-    while (elements--){
-	a = PDP_ATOM_ALLOC();
-	l->elements++;
-	a->t = a_undef;
-	a->w.w_int = 0;
-	a->next = l->first;
-	l->first = a;
-    }
-    return l;
-}
-
-/* clear a list */
-void pdp_list_clear(t_pdp_list *l)
-{
-    t_pdp_atom *a = l->first; 
-    t_pdp_atom *next_a;
-
-    while(a){
-	next_a = a->next;
-	PDP_ATOM_DEALLOC(a);
-	a = next_a;
-    }
-    l->first = 0;
-    l->last = 0;
-    l->elements = 0;
-}
-
-/* destroy a list */
-void pdp_list_free(t_pdp_list *l)
-{
-    if (l){
-	pdp_list_clear(l);
-	_pdp_list_dealloc(l);
-    }
-}
-
-
-/* destroy a (sub)tree */
-void pdp_tree_free(t_pdp_list *l)
-{
-  if (l) {
-    pdp_tree_clear(l);
-    _pdp_list_dealloc(l);
-  }
-}
-
-/* clear a tree */
-void pdp_tree_clear(t_pdp_list *l)
-{
-    t_pdp_atom *a = l->first; 
-    t_pdp_atom *next_a;
-
-    while(a){
-      if (a->t == a_list) pdp_tree_free(a->w.w_list);
-      next_a = a->next;
-      PDP_ATOM_DEALLOC(a);
-      a = next_a;
-    }
-    l->first = 0;
-    l->last = 0;
-    l->elements = 0;
-}
-
-
-static inline int _is_whitespace(char c){return (c == ' ' || c == '\n' || c == '\t');}
-static inline void _skip_whitespace(char **c){while (_is_whitespace(**c)) (*c)++;}
-static inline int _is_left_separator(char c) {return (c == '(');}
-static inline int _is_right_separator(char c) {return (c == ')');}
-static inline int _is_separator(char c) {return (_is_left_separator(c) || _is_right_separator(c) || _is_whitespace(c));}
-
-
-static inline void _parse_atom(t_pdp_word_type *t, t_pdp_word *w, char *c, int n)
-{
-    char tmp[n+1];
-    //post("_parse_atom(%d, %x, %s, %d)", *t, w, c, n); 
-    strncpy(tmp, c, n);
-    tmp[n] = 0;
-
-
-    /* check if it's a number */
-    if (tmp[0] >= '0' && tmp[0] <= '9'){
-	int is_float = 0;
-	char *t2;
-	for(t2 = tmp; *t2; t2++){
-	    if (*t2 == '.') {
-		is_float = 1;
-		break;
-	    }
-	}
-	/* it's a float */
-	if (is_float){
-	    float f = strtod(tmp, 0);
-	    D post("adding float %f", f);
-	    *t = a_float;
-	    *w = (t_pdp_word)f;
-	}
-
-	/* it's an int */
-	else {
-	    int i = strtol(tmp, 0, 0);
-	    D post("adding int %d", i);
-	    *t = a_int;
-	    *w = (t_pdp_word)i;
-	}
-	
-    }
-    /* it's a symbol */
-    else {
-	D post("adding symbol %s", tmp);
-	*t = a_symbol;
-	*w = (t_pdp_word)pdp_gensym(tmp);
-    }
-
-    D post("done parsing atom");
-
-}
-
-
-/* create a list from a character string */
-t_pdp_list *pdp_list_from_cstring(char *chardef, char **nextchar)
-{
-    t_pdp_list *l = pdp_list_new(0);
-    char *c = chardef;
-    char *lastname = c;
-    int n = 0;
-
-    D post ("creating list from char: %s", chardef);
-
-    /* find opening parenthesis and skip it*/
-    _skip_whitespace(&c);
-    if (!_is_left_separator(*c)) goto error; else c++;
-
-    /* start counting at the first non-whitespace
-       character after opening parenthesis */
-    _skip_whitespace(&c);
-    lastname = c;
-    n = 0;
-
-    while(*c){
-	if (!_is_separator(*c)){
-	    /* item not terminated: keep counting */
-	    c++;
-	    n++;
-	}
-	else {
-	    /* separator encountered whitespace or parenthesis */
-
-	    if (n){
-		/* if there was something between this and the previous
-		   separator, we've found and atom and parse it */
-		pdp_list_add_back(l, a_undef, (t_pdp_word)0);
-		_parse_atom(&l->last->t, &l->last->w, lastname, n);
-
-		/* skip the whitespace after the parsed word, if any */
-		_skip_whitespace(&c);
-	    }
-
-	    /* if we're at a right separator, we're done */
-	    if (_is_right_separator(*c)) {c++; goto done;}
-
-	    /* if it's a left separater, we have a sublist */
-	    if (_is_left_separator(*c)){
-		t_pdp_list *sublist = pdp_list_from_cstring(c, &c);
-		if (!sublist) goto error; //sublist had parse error
-		pdp_list_add_back(l, a_list, (t_pdp_word)sublist);
-	    }
-
-	    /* prepare for next atom */
-	    lastname = c;
-	    n = 0;
-	}
-
-    }
-
- error:
-    /* end of string encountered: parse error */
-    D post("parse error: %s", c);
-    if (nextchar) *nextchar = c;
-    pdp_tree_free(l); //this will free all sublists too
-    return 0;
-
-	
- done:
-    _skip_whitespace(&c);
-    if (nextchar) *nextchar = c;
-    return l;
-    
-    
-
-}
-
-
-/* traversal */
-void pdp_list_apply(t_pdp_list *l, t_pdp_atom_method m)
-{
-  t_pdp_atom *a;
-  if (!l) return;
-  for (a=l->first; a; a=a->next) m(a);
-}
-
-void pdp_tree_apply(t_pdp_list *l, t_pdp_atom_method m) 
-{
-  t_pdp_atom *a;
-  if (!l) return;
-  for (a=l->first; a; a=a->next){
-    if (a->t == a_list) pdp_tree_apply(a->w.w_list, m);
-    else m(a);
-  }
-}
-
-void pdp_list_apply_word_method(t_pdp_list *l, 
-				t_pdp_word_type type, t_pdp_word_method wm)
-{
-  t_pdp_atom *a;
-  if (!l) return;
-  for (a=l->first; a; a=a->next){
-    if (a->t == type) wm(a->w);
-  }
-}
-void pdp_list_apply_pword_method(t_pdp_list *l, 
-				t_pdp_word_type type, t_pdp_pword_method pwm)
-{
-  t_pdp_atom *a;
-  if (!l) return;
-  for (a=l->first; a; a=a->next){
-    if (a->t == type) pwm(&a->w);
-  }
-}
-
-void pdp_tree_apply_word_method(t_pdp_list *l, 
-				t_pdp_word_type type, t_pdp_word_method wm) 
-{
-  t_pdp_atom *a;
-  if (!l) return;
-  for (a=l->first; a; a=a->next){
-    if (a->t == a_list) pdp_tree_apply_word_method(a->w.w_list, type, wm);
-    else if (a->t == type) wm(a->w);
-  }
-}
-void pdp_tree_apply_pword_method(t_pdp_list *l, 
-				t_pdp_word_type type, t_pdp_pword_method pwm) 
-{
-  t_pdp_atom *a;
-  if (!l) return;
-  for (a=l->first; a; a=a->next){
-    if (a->t == a_list) pdp_tree_apply_pword_method(a->w.w_list, type ,pwm);
-    else if (a->t == type) pwm(&a->w);
-  }
-}
-
-static void _atom_packet_mark_unused(t_pdp_atom *a)
-{
-  if (a->t == a_packet){
-    pdp_packet_mark_unused(a->w.w_packet);
-    a->t = a_undef;
-    a->w.w_int = 0;
-  }
-}
-
-void pdp_tree_strip_packets  (t_pdp_list *l)
-{
-   pdp_tree_apply(l, _atom_packet_mark_unused);
-}
-
-
-/* debug */
-static void _pdp_atomlist_fprint(FILE* f, t_pdp_atom *a)
-{
-    fprintf(f, "(");
-    while (a){
-	switch(a->t){
-	case a_symbol:   fprintf(f, "%s",a->w.w_symbol->s_name); break;
-	case a_float:    fprintf(f, "%f",a->w.w_float); break;
-	case a_int:      fprintf(f, "%d",a->w.w_int); break;
-	case a_packet:   fprintf(f, "#<pdp %d %s>",a->w.w_packet,
-				 pdp_packet_get_description(a->w.w_packet)->s_name); break;
-	case a_pointer:  fprintf(f, "#<0x%08x>",(unsigned int)a->w.w_pointer); break;
-	case a_list:     _pdp_atomlist_fprint(f, a->w.w_list->first); break;
-	case a_undef:    fprintf(f, "undef"); break;
-
-	default:         fprintf(f, "unknown"); break;
-	}
-       	a = a->next;
-	if (a) fprintf(f, " ");
-    }
-    fprintf(f, ")");
-}
-
-void _pdp_list_fprint(FILE* f, t_pdp_list *l)
-{
-    _pdp_atomlist_fprint(f, l->first);
-    fprintf(f, "\n");
-}
-
-void pdp_list_print(t_pdp_list *l)
-{
-    _pdp_list_fprint(stderr, l);
-}
-
-
-/* public list operations */
-
-
-/* add a word to the start of the list */
-void pdp_list_add(t_pdp_list *l, t_pdp_word_type t, t_pdp_word w)
-{
-    t_pdp_atom *new_a = PDP_ATOM_ALLOC();
-    l->elements++;
-    new_a->next = l->first;
-    new_a->w = w;
-    new_a->t = t;
-    l->first = new_a;
-    if (!l->last) l->last = new_a;
-}
-
-
-/* add a word to the end of the list */
-void pdp_list_add_back(t_pdp_list *l, t_pdp_word_type t, t_pdp_word w)
-{
-    t_pdp_atom *new_a = PDP_ATOM_ALLOC();
-    l->elements++;
-    new_a->next = 0;
-    new_a->w = w;
-    new_a->t = t;
-    if (l->last){
-	l->last->next = new_a;
-    }
-    else{
-	l->first = new_a;
-    }
-    l->last = new_a;
-}
-
-/* get list size */
-int pdp_list_size(t_pdp_list *l)
-{
-    return l->elements;
-}
-
-
-
-
-/* pop: return first item and remove */
-t_pdp_word pdp_list_pop(t_pdp_list *l)
-{
-    t_pdp_atom *a = l->first;
-    t_pdp_word w;
-
-    w = a->w;
-    l->first = a->next;
-    PDP_ATOM_DEALLOC(a);
-    l->elements--;
-    if (!l->first) l->last = 0;
-
-    return w;
-}
-
-
-/* return element at index */
-t_pdp_word pdp_list_index(t_pdp_list *l, int index)
-{
-    t_pdp_atom *a;
-    for (a = l->first; index--; a = a->next);
-    return a->w;
-}
-
-
-
-
-
-/* remove an element from a list */
-void pdp_list_remove(t_pdp_list *l, t_pdp_word_type t, t_pdp_word w)
-{
-    t_pdp_atom head;
-    t_pdp_atom *a;
-    t_pdp_atom *kill_a;
-    head.next = l->first;
-
-    for(a = &head; a->next; a = a->next){
-	if (a->next->w.w_int == w.w_int && a->next->t == t){
-	    kill_a = a->next;        // element to be killed
-	    a->next = a->next->next; // remove link
-	    PDP_ATOM_DEALLOC(kill_a);
-	    l->elements--;
-	    l->first = head.next;    // restore the start pointer
-	    if (l->last == kill_a) { // restore the end pointer
-		l->last = (a != &head) ? a : 0;
-	    }
-
-	    break;
-	}
-    }
-    
-}
-
-
-
-
-
-/* copy a list */
-t_pdp_list* pdp_tree_copy_reverse(t_pdp_list *list)
-{
-    t_pdp_list *newlist = pdp_list_new(0);
-    t_pdp_atom *a;
-    for (a = list->first; a; a = a->next)
-	if (a->t == a_list){
-	    pdp_list_add(newlist, a->t, 
-			 (t_pdp_word)pdp_tree_copy_reverse(a->w.w_list));
-	}
-	else{
-	    pdp_list_add(newlist, a->t, a->w);
-	}
-    return newlist;
-}
-t_pdp_list* pdp_list_copy_reverse(t_pdp_list *list)
-{
-    t_pdp_list *newlist = pdp_list_new(0);
-    t_pdp_atom *a;
-    for (a = list->first; a; a = a->next)
-      pdp_list_add(newlist, a->t, a->w);
-    return newlist;
-}
-
-t_pdp_list* pdp_tree_copy(t_pdp_list *list)
-{
-    t_pdp_list *newlist = pdp_list_new(list->elements);
-    t_pdp_atom *a_src = list->first;
-    t_pdp_atom *a_dst = newlist->first;
-
-    while(a_src){
-	a_dst->t = a_src->t;
-	if (a_dst->t == a_list){ //recursively copy sublists (tree copy)
-	    a_dst->w.w_list = pdp_tree_copy(a_src->w.w_list);
-	}
-	else{
-	    a_dst->w = a_src->w;
-	}
-	a_src = a_src->next;
-	a_dst = a_dst->next;
-    }
-
-    return newlist;
-}
-t_pdp_list* pdp_list_copy(t_pdp_list *list)
-{
-    t_pdp_list *newlist = pdp_list_new(list->elements);
-    t_pdp_atom *a_src = list->first;
-    t_pdp_atom *a_dst = newlist->first;
-
-    while(a_src){
-	a_dst->t = a_src->t;
-	a_dst->w = a_src->w;
-	a_src = a_src->next;
-	a_dst = a_dst->next;
-    }
-    return newlist;
-}
-
-void pdp_list_cat (t_pdp_list *l, t_pdp_list *tail)
-{
-    t_pdp_list *tmp = pdp_list_copy(tail);
-    l->elements += tmp->elements;
-    l->last->next = tmp->first;
-    l->last = tmp->last;
-    _pdp_list_dealloc(tmp); //delete the list stub
-    
-}
-
-
-/* check if a list contains an element */
-int pdp_list_contains(t_pdp_list *list, t_pdp_word_type t, t_pdp_word w)
-{
-    t_pdp_atom *a;
-    for(a = list->first; a; a=a->next){
-	if (a->w.w_int == w.w_int && a->t == t) return 1;
-    }
-    return 0;
-}
-
-/* add a thing to the start of the list if it's not in there already */
-void pdp_list_add_to_set(t_pdp_list *list, t_pdp_word_type t, t_pdp_word w)
-{
-    if (!pdp_list_contains(list, t, w))
-	pdp_list_add(list, t, w);
-}
-
-
-
diff --git a/system/kernel/pdp_mem.c b/system/kernel/pdp_mem.c
deleted file mode 100644
index 33822ef..0000000
--- a/system/kernel/pdp_mem.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- *   Pure Data Packet system file: memory allocation
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <stdlib.h>
-#include "pdp_mem.h"
-#include "pdp_debug.h"
-
-
-/* malloc wrapper that calls garbage collector */
-void *pdp_alloc(int size)
-{
-    void *ptr = malloc(size);
-    
-    PDP_ASSERT(ptr);
-
-    return ptr;
-
-    //TODO: REPAIR THIS
-    //post ("malloc failed in a pdp module: running garbage collector.");
-    //pdp_pool_collect_garbage();
-    //return malloc(size);
-}
-
-
-void pdp_dealloc(void *stuff)
-{
-    free (stuff);
-}
-
-
-/* fast atom allocation object
-   well, this is not too fast yet, but will be later
-   when it suports linux futexes or atomic operations */
-
-//#include <pthread.h>
-
-/* private linked list struct */
-typedef struct _fastalloc
-{
-  struct _fastalloc * next;
-} t_fastalloc;
-
-
-
-
-static void _pdp_fastalloc_lock(t_pdp_fastalloc *x){pthread_mutex_lock(&x->mut);}
-static void _pdp_fastalloc_unlock(t_pdp_fastalloc *x){pthread_mutex_unlock(&x->mut);}
-
-static void _pdp_fastalloc_refill_freelist(t_pdp_fastalloc *x)
-{
-    t_fastalloc *atom;
-    unsigned int i;
-
-    PDP_ASSERT(x->freelist == 0);
-
-    /* get a new block 
-       there is no means of freeing the data afterwards,
-       this is a fast implementation with the tradeoff of data
-       fragmentation "memory leaks".. */
-
-    x->freelist = pdp_alloc(x->block_elements * x->atom_size);
-
-    /* link all atoms together */
-    atom = x->freelist;
-    for (i=0; i<x->block_elements-1; i++){
-      atom->next = (t_fastalloc *)(((char *)atom) + x->atom_size);
-      atom = atom->next;
-    }
-    atom->next = 0;
-    
-}
-
-void *pdp_fastalloc_new_atom(t_pdp_fastalloc *x)
-{
-  t_fastalloc *atom;
-
-  _pdp_fastalloc_lock(x);
-
-  /* get an atom from the freelist
-     or refill it and try again */
-  while (!(atom = x->freelist)){
-    _pdp_fastalloc_refill_freelist(x);
-  }
-
-  /* delete the element from the freelist */
-  x->freelist = x->freelist->next;
-  atom->next = 0;
-
-  _pdp_fastalloc_unlock(x);
-
-  return (void *)atom;
-	 
-}
-void pdp_fastalloc_save_atom(t_pdp_fastalloc *x, void *atom)
-{
-  _pdp_fastalloc_lock(x);
-  ((t_fastalloc *)atom)->next = x->freelist;
-  x->freelist = (t_fastalloc *)atom;
-  _pdp_fastalloc_unlock(x);
-}
-
-t_pdp_fastalloc *pdp_fastalloc_new(unsigned int size)
-{
-  t_pdp_fastalloc *x = pdp_alloc(sizeof(*x));
-  if (size < sizeof(t_fastalloc)) size = sizeof(t_fastalloc);
-  x->freelist = 0;
-  x->atom_size = size;
-  x->block_elements = PDP_FASTALLOC_BLOCK_ELEMENTS;
-  pthread_mutex_init(&x->mut, NULL);
-  return x;
-}
-
diff --git a/system/kernel/pdp_packet.c b/system/kernel/pdp_packet.c
deleted file mode 100644
index a811381..0000000
--- a/system/kernel/pdp_packet.c
+++ /dev/null
@@ -1,957 +0,0 @@
-/*
- *   Pure Data Packet system implementation: Packet Manager
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-#include "pdp.h"
-#include <stdio.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <string.h>
-
-
-/* TODO:
-   implement an indexing system to the packet pool (array) to speed up searches.
-   -> a list of lists of recycled packes, arranged by packet type.
-   -> a list of unused slots
-*/
-   
-
-
-#define D if (0)
-
-/* all symbols are C style */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-/* pdp specific constants */
-#define PDP_ALIGN 8
-
-/* this needs to be able to grow dynamically, think about it later */
-/* for ordinary work, this is enough and can help finding memory leaks */
-
-#define PDP_INITIAL_POOL_SIZE 1
-#define PDP_PACKET_MAX_MEM_USAGE -1
-
-/* the pool */
-static unsigned int pdp_packet_mem_usage;
-static unsigned int pdp_packet_max_mem_usage;
-static int pdp_pool_size;
-static t_pdp** pdp_pool;
-
-/* this is for detecting memory leaks */
-static int pdp_packet_count;
-
-/* some global vars */
-static t_symbol* pdp_sym_register_rw;
-static t_symbol* pdp_sym_register_ro;
-static t_symbol* pdp_sym_process;
-
-/* mutex */
-static pthread_mutex_t pdp_pool_mutex;
-
-/* the list of classes */
-static t_pdp_list *class_list;
-
-/* debug */
-void
-pdp_packet_print_debug(int packet)
-{
-    t_pdp *h = pdp_packet_header(packet);
-    post("debug info for packet %d", packet);
-    if (!h){
-	post("invalid packet");
-    }
-    else{
-	post ("\ttype: %d", h->type);
-	post ("\tdesc: %s", h->desc ? h->desc->s_name : "unknown");
-	post ("\tsize: %d", h->size);
-	post ("\tflags: %x", h->flags);
-	post ("\tusers: %d", h->users);
-	post ("\trefloc: %x", h->refloc);
-	post ("\tclass: %x", h->theclass);
-    }
-}
-
-
-
-/* setup methods */
-
-void 
-pdp_packet_setup(void)
-{
-
-    pdp_pool_size = PDP_INITIAL_POOL_SIZE;
-    pdp_packet_count = 0;
-    pdp_packet_mem_usage = 0;
-    pdp_packet_max_mem_usage = PDP_PACKET_MAX_MEM_USAGE;
-    pdp_pool = (t_pdp **)malloc(PDP_INITIAL_POOL_SIZE * sizeof(t_pdp *));
-    bzero(pdp_pool, pdp_pool_size * sizeof(t_pdp *));
-    pdp_sym_register_rw = gensym("register_rw");
-    pdp_sym_register_ro = gensym("register_ro");
-    pdp_sym_process = gensym("process");
-    pdp_packet_count = 0;
-    class_list = pdp_list_new(0);
-
-    pthread_mutex_init(&pdp_pool_mutex, NULL);
-}
-
-/* class methods */
-t_pdp_class *pdp_class_new(t_pdp_symbol *type, t_pdp_factory_method create){
-    t_pdp_class *c = (t_pdp_class *)pdp_alloc(sizeof(t_pdp_class));
-    memset(c, 0, sizeof(t_pdp_class));
-    c->create = create;
-    c->type = type; // set type
-    //c->attributes = pdp_list_new(0); // create an empty attribute list
-    pdp_list_add(class_list, a_pointer, (t_pdp_word)((void *)c));
-    //post("added class %s %x", c->type->s_name, c->create);
-
-    return c;
-}
-
-#if 0
-void pdp_class_addmethod(t_pdp_class *c, t_pdp_symbol *name, t_pdp_attribute_method method,
-			 t_pdp_list *in_spec, t_pdp_list *out_spec)
-{
-    t_pdp_attribute *attr = (t_pdp_attribute *)pdp_alloc(sizeof(t_pdp_attribute));
-    attr->name = name;
-    attr->method = method;
-    attr->in_spec = in_spec;
-    attr->out_spec = out_spec;
-    pdp_list_add_pointer(c->attributes, attr);
-    
-}
-#endif
-
-/* the packet factory */
-int pdp_factory_newpacket(t_pdp_symbol *type)
-{
-    t_pdp_class *c;
-    t_pdp_atom *a = class_list->first;
-    while(a){
-	c = (t_pdp_class *)(a->w.w_pointer);
-	if (c->type && pdp_type_description_match(type, c->type)){
-	    //post("method %x, type %s", c->create, type->s_name);
-	    return (c->create) ? (*c->create)(type) : -1;
-	}
-	a = a->next;
-    }
-    return -1;
-}
-
-#if 0
-/* generic methods. actually a forth word operation on a stack.
-   first item on stack must be a packet and it's type will
-   determine the place to look for the operator */
-int pdp_packet_op(t_pdp_symbol *operation, struct _pdp_list *stack)
-{
-    int packet = stack->first->w.w_packet;
-    t_pdp *h = pdp_packet_header(packet);
-    t_pdp_atom *i;
-    t_pdp_attribute *attr;
-
-    if (!(h && h->theclass)) goto exit;       
-
-    PDP_POINTER_IN(h->theclass->attributes, i, attr){
-	//post("attribute:%s", attr->name->s_name);
-	if (attr->name == operation){
-	    
-	    /* FOUND -> exec (check arguments first ???) */
-	    return attr->method (stack);
-	}
-	
-    }
- exit:
-    // method not found
-    post ("WARNING: pdp_packet_op: packet %d from class %s has no operation %s", 
-	  packet, (h && h->theclass) ? h->theclass->type->s_name : "UNKNOWN", operation->s_name);
-    return 0;
-}
-
-#endif
-
-static void
-_pdp_pool_expand(void){
-    int i;
-
-    /* double the size */
-    int new_pool_size = pdp_pool_size << 1;
-    t_pdp **new_pool = (t_pdp **)malloc(new_pool_size * sizeof(t_pdp *));
-    bzero(new_pool, new_pool_size * sizeof(t_pdp *));
-    memcpy(new_pool, pdp_pool, pdp_pool_size * sizeof(t_pdp *));
-    free(pdp_pool);
-    pdp_pool = new_pool;
-    pdp_pool_size = new_pool_size;
-
-    D post("DEBUG: _pdp_pool_expand: resized pool to contain %d packets", pdp_pool_size);
-}
-
-
-
-
-/* private _pdp_packet methods */
-
-/* packets can only be created and destroyed using these 2 methods */
-/* it updates the mem usage and total packet count */
-
-static void
-_pdp_packet_dealloc(t_pdp *p)
-{
-    unsigned int size = p->size;
-    if (p->theclass && p->theclass->cleanup)
-	(*p->theclass->cleanup)(p);
-
-    free (p);
-    pdp_packet_mem_usage -= size;
-    pdp_packet_count--;
-    D post("DEBUG: _pdp_packet_new_dealloc: freed packet. pool contains %d packets", pdp_packet_count);
-}
-
-static t_pdp*
-_pdp_packet_alloc(unsigned int datatype, unsigned int datasize)
-{
-    unsigned int totalsize = datasize + PDP_HEADER_SIZE;
-    unsigned int align;
-    t_pdp *p = 0;
-
-    /* check if there is a memory usage limit */
-    if (pdp_packet_max_mem_usage){
-	/* if it would exceed the limit, fail */
-	if (pdp_packet_mem_usage + totalsize > pdp_packet_max_mem_usage){
-	    D post("DEBUG: _pdp_packet_new_alloc: memory usage limit exceeded");
-	    return 0;
-	}
-    }
-    p = (t_pdp *)malloc(totalsize);
-    if (p){
-	align = ((unsigned int)p) & (PDP_ALIGN - 1);
-	if (align) post("WARNING: _pdp_packet_alloc: data misaligned by %x", align);
-	memset(p, 0, PDP_HEADER_SIZE); //initialize header to 0
-	p->type = datatype;
-	p->size = totalsize;
-	p->users = 1;
-	pdp_packet_mem_usage += totalsize;
-	pdp_packet_count++;
-	D post("DEBUG: _pdp_packet_new_alloc: allocated new packet. pool contains %d packets, using %d bytes",
-	       pdp_packet_count, pdp_packet_mem_usage);
-    }
-
-    return p;
-}
-
-
-void 
-pdp_packet_destroy(void)
-{
-    int i = 0;
-    /* dealloc all the data in object stack */
-    post("DEBUG: pdp_packet_destroy: clearing object pool.");
-    while ((i < pdp_pool_size) && (pdp_pool[i])) _pdp_packet_dealloc(pdp_pool[i++]);
-}
-
-
-
-/* try to find a packet based on main type and datasize */
-static int
-_pdp_packet_reuse_type_size(unsigned int datatype, unsigned int datasize)
-{
-    unsigned int totalsize = datasize + PDP_HEADER_SIZE;
-    int i = 0;
-    int return_packet = -1;
-    t_pdp* p;
-
-    for (i=0; i < pdp_pool_size; i++){
-	p = pdp_pool[i];
-	/* check if we can reuse this one if it is already allocated */
-	if (p) {
-	    /* search for unused packets of equal size & type */
-	    if ((p->users == 0) && (p->size == totalsize) && (p->type == datatype)){
-		D post("DEBUG: _pdp_packet_reuse_type_size: can reuse %d", i);
-		
-		/* if possible, a packet will be reused and reinitialized
-		   i haven't found a use for this, so it's only used for discriminating
-		   between pure and not-so-pure packets */ 
-		if (p->theclass && p->theclass->reinit){
-		    (*p->theclass->reinit)(p);
-		}
-		/* if no re-init method is found, the header will be reset to all 0
-		   this ensures the header is in a predictable state */
-		else {
-		    memset(p, 0, PDP_HEADER_SIZE);
-		    p->type = datatype;
-		    p->size = totalsize;
-		}
-
-		p->users = 1;
-		return_packet = i;
-		goto exit;
-	    }
-	    else{
-	      D post("DEBUG _pdp_packet_reuse_type_size: can't reuse %d, (%d users)", i, p->users);
-	    }
-	}
-    }
-
-    D post("DEBUG: _pdp_packet_reuse_type_size: no reusable packet found");
-
- exit:
-    return return_packet;
-}
-
-
-/* create a new packet in an empty slot.
-   if this fails, the garbage collector needs to be called */
-static int 
-_pdp_packet_create_in_empty_slot(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    unsigned int totalsize = datasize + PDP_HEADER_SIZE;
-    int i = 0;
-    int return_packet = -1;
-    int out_of_mem = 0;
-    t_pdp* p;
-
-
-    /* no reusable packets found, try to find an empty slot */
-    for (i=0; i < pdp_pool_size; i++){
-	p = pdp_pool[i];
-	if (!p) {
-	    p = _pdp_packet_alloc(datatype, datasize);
-
-	    if (!p) {
-		D post("DEBUG: _pdp_packet_create_in_empty_slot: out of memory (malloc returned NULL)");
-		return_packet = -1;
-		goto exit;
-	    }
-
-	    pdp_pool[i] = p;
-	    return_packet = i;
-	    goto exit;
-	}
-    }
-
-    /* if we got here the pool is full: resize the pool and try again */
-    _pdp_pool_expand();
-    return_packet = _pdp_packet_create_in_empty_slot(datatype, datasize);
-
- exit:
-    return return_packet;
-
-}
-
-/* find an unused packet, free it and create a new packet.
-   if this fails, something is seriously wrong */
-static int 
-_pdp_packet_create_in_unused_slot(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    unsigned int totalsize = datasize + PDP_HEADER_SIZE;
-    int i = 0;
-    int return_packet = -1;
-    int out_of_mem = 0;
-    t_pdp* p;
-
-    D post("DEBUG: _pdp_packet_create_in_unused_slot: collecting garbage");
-		
-    /* search backwards */
-    for (i=pdp_pool_size-1; i >= 0; i--){
-	p = pdp_pool[i];
-	if (p){
-	    if (p->users == 0){
-		_pdp_packet_dealloc(p);
-		p = _pdp_packet_alloc(datatype, datasize);
-		pdp_pool[i] = p;
-
-		/* alloc succeeded, return */
-		if (p) {
-		    post("DEBUG _pdp_packet_create_in_unused_slot: garbage collect succesful");
-		    return_packet = i;
-		    goto exit;
-		}
-
-		/* alloc failed, continue collecting garbage */
-		D post("DEBUG _pdp_packet_create_in_unused_slot: freed one packet, still out of memory (malloc returned NULL)");
-		out_of_mem = 1;
-	    
-	    }
-	}
-    }
-
-    /* if we got here, we ran out of memory */
-    D post("DEBUG: _pdp_packet_create_in_unused_slot: out of memory after collecting garbage");
-    return_packet = -1;
-
-exit:
-    return return_packet;
-}
-
-/* warning: for "not so pure" packets, this method will only return an initialized
-   packet if it can reuse a privious one. that is, if it finds a reinit method
-   in the packet. use the pdp_packet_new_<type> constructor if possible */
-
-static int 
-_pdp_packet_brandnew(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    int return_packet = -1;
-
-    /* try to create a new packet in an empty slot */
-    return_packet = _pdp_packet_create_in_empty_slot(datatype, datasize);
-    if (return_packet != -1) goto exit;
-
-    /* if we still don't have a packet, we need to call the garbage collector until we can allocate */
-    return_packet = _pdp_packet_create_in_unused_slot(datatype, datasize);
-
- exit:
-    return return_packet;
-}
-
-
-static int
-_pdp_packet_new(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    int return_packet = -1;
-
-    /* try to reuse a packet based on main type and datasize */
-    return_packet = _pdp_packet_reuse_type_size(datatype, datasize);
-    if (return_packet != -1) goto exit;
-
-    /* create a brandnew packet */
-    return_packet = _pdp_packet_brandnew(datatype, datasize);
-    if (return_packet != -1) goto exit;
-
-    post("WARNING: maximum packet memory usage limit (%d bytes) reached after garbage collect.", pdp_packet_max_mem_usage);
-    post("WARNING: increase memory limit or decrease packet usage (i.e. pdp_loop, pdp_delay).");
-    post("WARNING: pool contains %d packets, using %d bytes.", pdp_packet_count, pdp_packet_mem_usage);
-
- exit:
-    return return_packet;
-       
-}
-
-
-
-/* public pool operations: have to be thread safe so each entry point
-   locks the mutex */
-
-/* reuse an old packet based on high level description */
-int
-pdp_packet_reuse(t_pdp_symbol *description)
-{
-    int i;
-    int return_packet = -1;
-    t_pdp *p;
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    for (i=0; i < pdp_pool_size; i++){
-	p = pdp_pool[i];
-	/* check if we can reuse this one if it is already allocated */
-	if ((p) && (p->users == 0) && (p->desc == description)){
-	    /* mark it as used */
-	    p->users = 1;
-	    return_packet = i;
-	    goto gotit; 
-	}
-    }
-
- gotit:
-    /* LOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-    return return_packet;
-
-
-}
-
-/* create a new packet, or reuse an old one based on main type and size */
-int 
-pdp_packet_new(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    int packet;
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    packet = _pdp_packet_new(datatype, datasize);
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-    return packet;
-}
-
-
-/* create a brand new packet, don't reuse an old one */
-int 
-pdp_packet_brandnew(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    int packet;
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    packet = _pdp_packet_brandnew(datatype, datasize);
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-    return packet;
-}
-
-
-/* this returns a copy of a packet for read only access. */
-int
-pdp_packet_copy_ro(int handle)
-{
-    int out_handle = -1;
-    t_pdp* p;
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    if ((handle >= 0) 
-	&& (handle < pdp_pool_size) 
-	&& (p = pdp_pool[handle])){
-
-	/* it is an error to copy a packet without an owner */
-	if (!p->users){
-	    post("pdp_packet_copy_ro: ERROR: request to copy packet %d which has 0 users", handle);
-	    out_handle = -1;
-	}
-
-	/* if it's a passing packet, reset the reference location
-	   and turn it into a normal packet */
-	else if (p->refloc){
-	    *p->refloc = -1;
-	    p->refloc = 0;
-	    out_handle = handle;
-	}
-	/* if it's a normal packet, increase the number of users */
-	else {
-	    p->users++;
-	    out_handle = handle;
-	}
-    }
-    else out_handle = -1;
-
-    //post("pdp_copy_ro: outhandle:%d", out_handle);
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-    return out_handle;
-}
-
-/* copy a packet. if the packet is marked passing, it will be aquired.
-   otherwize a new packet will be created with a copy of the contents. */
-
-int
-pdp_packet_copy_rw(int handle)
-{
-    int out_handle = -1;
-    t_pdp* p;
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    if ((handle >= 0) 
-	&& (handle < pdp_pool_size) 
-	&& (p = pdp_pool[handle])){
-	/* if there are other users, copy the object otherwize return the same handle */
-
-	/* it is an error to copy a packet without an owner */
-	if (!p->users){
-	    post("pdp_packet_copy_rw: ERROR: request to copy packet %d which has 0 users", handle);
-	    out_handle = -1;
-	}
-
-	/* if it is a passing packet, remove the owner's reference to it */
-	else if (p->refloc){
-	    *p->refloc = -1;
-	    p->refloc = 0;
-	    out_handle = handle;
-	}
-
-	/* check if packet supports copy (for fanout) */
-	else if(p->flags & PDP_FLAG_DONOTCOPY) out_handle = -1;
-
-
-	/* copy the packet, since it already has 1 or more users */
-	else{
-	    int new_handle = _pdp_packet_new(p->type, p->size - PDP_HEADER_SIZE);
-	    t_pdp* new_p = pdp_packet_header(new_handle);
-
-	    /* check if valid */
-	    if (!new_p) out_handle = -1;
-
-	    else {
-		/* if a copy constructor is found, it will be called */
-		if (p->theclass && p->theclass->copy){
-		    (*p->theclass->copy)(new_p, p);
-		}
-		/* if not, the entire packet will be copied, assuming a pure data packet */
-		else {
-		    memcpy(new_p, p, p->size);
-		}
-		new_p->users = 1;
-		out_handle = new_handle;
-	    }
-	}
-
-	//post("pdp_copy_rw: inhandle:%d outhandle:%d", handle, out_handle);
-
-    }
-    else out_handle = -1;
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-    return out_handle;
-}
-
-/* create a new packet, copying the header data of another
-   packet, without copying the data */
-int
-pdp_packet_clone_rw(int handle)
-{
-    int out_handle;
-    t_pdp* p;
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    if ((handle >= 0) 
-	&& (handle < pdp_pool_size) 
-	&& (p = pdp_pool[handle])){
-
-	/* clone the packet header, don't copy the data */
-	int new_handle = _pdp_packet_new(p->type, p->size - PDP_HEADER_SIZE);
-	t_pdp* new_p = pdp_packet_header(new_handle);
-
-	/* if a clone initializer is found, it will be called */
-	if (p->theclass && p->theclass->clone){
-	    (*p->theclass->clone)(new_p, p);
-	}
-	/* if not, just the header will be copied, assuming a pure data packet */
-	else {
-	    memcpy(new_p, p, PDP_HEADER_SIZE);
-	}
-	new_p->users = 1;   /* the new packet has 1 user */
-	new_p->refloc = 0;  /* it is not a passing packet, even if the template was */
-	out_handle = new_handle;
-    }
-
-    else out_handle = -1;
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-    return out_handle;
-}
-
-void
-_pdp_packet_mark_unused_nolock(int handle)
-{
-    t_pdp* p;
-
-    if ((handle >= 0) && (handle < pdp_pool_size)){
-      if (p = pdp_pool[handle]) {
-	  /* mark_unused on a passing packet has no effect
-	     this is to support automatic conversion for passing packets
-	     so in order to delete a passing packet, it should be marked normal first */
-	  if (p->refloc){
-	      post("DEBUG: pdp_mark_unused called on a passing packet. ignored.");
-	      return;
-	  }
-
-	  /* decrease the refcount */
-	  if (p->users) {
-	      p->users--;
-	      //post("pdp_mark_unused: handle %d, users left %d", handle, p->users);
-	  }
-	  else {
-	      post("pdp_mark_unused: ERROR: handle %d has zero users (duplicate pdp_mark_unused ?)", handle);
-	}
-      }
-      else {
-	  post("pdp_mark_unused: ERROR: invalid handle %d: no associated object", handle);
-      }
-    }
-    
-    else {
-	/* -1 is the only invalid handle that doesn't trigger a warning */
-	if (handle != -1) post("pdp_mark_unused: WARNING: invalid handle %d: out of bound", handle);
-    }
-
-}
-
-/* mark a packet as unused, decreasing the reference count.
-   if the reference count reaches zero, the packet is ready to be recycled
-   by a new packet allocation. it is illegal to reference a packet with
-   reference count == zero. if the reference count is not == 1, only readonly
-   access is permitted. */
-
-void
-pdp_packet_mark_unused(int handle)
-{
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    _pdp_packet_mark_unused_nolock(handle);
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-}
-
-void
-pdp_packet_mark_unused_atomic(int *handle)
-{
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    _pdp_packet_mark_unused_nolock(*handle);
-    *handle = -1;
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-}
-
-/* delete a packet. this is more than mark_unused:
-   it actually removes any reference. can be used for
-   some packet types that have "expensive" resources. 
-   usually this is up to the garbage collector to call. */
-
-void
-pdp_packet_delete(int handle)
-{
-    t_pdp *header = pdp_packet_header(handle);
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-
-    /* check if it's a valid handle */
-    if ((handle >= 0) && (handle < pdp_pool_size) && pdp_pool[handle]){
-
-	/* mark it unused */
-	_pdp_packet_mark_unused_nolock(handle);
-
-	/* if no users, dealloc */
-	if (!header->users){
-	    _pdp_packet_dealloc(header);
-	    pdp_pool[handle] = NULL;
-	}
-
-	/* print a warning if failed */
-	else{
-	    post("WARNING: pdp_packet_delete: packet %d was not deleted. %d users remaining", 
-		 handle, header->users);
-	}
-    }
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-}
-
-
-/* this turns any packet into a normal (non-passing) packet */
-
-void
-pdp_packet_unmark_passing(int packet)
-{
-    t_pdp* header = pdp_packet_header(packet);
-    if (!header) return;
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    header->refloc = 0;
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-}
-
-
-/* this marks a packet as passing. this means it changes
-   owner on first copy_ro or copy_rw. the previous owner is
-   notified by setting the handler to -1. */
-
-void
-pdp_packet_mark_passing(int *phandle)
-{
-    t_pdp* header = pdp_packet_header(*phandle);
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    if (header){
-	if (header->refloc){
-	    post("pdp_packet_mark_passing: ERROR: duplicate mark_passing on packet %d", *phandle);
-	}
-	else if (1 != header->users){
-	    post("pdp_packet_mark_passing: ERROR: packet %d is not exclusively owned by caller, it has %d users", *phandle, header->users);
-	}
-	else {
-	    header->refloc = phandle;
-	}
-    }
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-}
-
-
-/* public data access methods */
-
-t_pdp*
-pdp_packet_header(int handle)
-{
-    if ((handle >= 0) && (handle < pdp_pool_size)) return pdp_pool[handle];
-    else return 0;
-}
-
-void*
-pdp_packet_subheader(int handle)
-{
-    t_pdp* header = pdp_packet_header(handle);
-    if (!header) return 0;
-    return (void *)(&header->info.raw);
-}
-
-void*
-pdp_packet_data(int handle)
-{
-    t_pdp *h;
-    if ((handle >= 0) && (handle < pdp_pool_size)) 
-	{
-	    h = pdp_pool[handle];
-	    if (!h) return 0;
-	    return (char *)(h) + PDP_HEADER_SIZE;
-	}
-    else return 0;
-}
-
-
-/* OBSOLETE: use packet description */
-/* check if two packets are allocated and of the same type */
-bool pdp_packet_compat(int packet0, int packet1)
-{
-
-    t_pdp *header0 = pdp_packet_header(packet0);
-    t_pdp *header1 = pdp_packet_header(packet1);
-
-    if (!(header1)){
-	//post("pdp_type_compat: invalid header packet1");
-	return 0;
-    }
-    if (!(header0)){
-	//post("pdp_type_compat: invalid header packet 0");
-	return 0;
-    }
-    if (header0->type != header1->type){
-	//post("pdp_type_compat: types do not match");
-	return 0;
-    }
-
-    return 1;
-}
-
-int pdp_packet_writable(int packet) /* returns true if packet is writable */
-{
-    t_pdp *h = pdp_packet_header(packet);
-    if (!h) return 0;
-    return (h->users == 1);
-}
-
-void pdp_packet_replace_with_writable(int *packet) /* replaces a packet with a writable copy */
-{
-    int new_p;
-    if (!pdp_packet_writable(*packet)){
-	new_p = pdp_packet_copy_rw(*packet);
-	pdp_packet_mark_unused(*packet);
-	*packet = new_p;
-    }
-	
-}
-
-/* pool stuff */
-
-int
-pdp_pool_collect_garbage(void)
-{
-    t_pdp *p;
-    int i;
-    int nbpackets = pdp_packet_count;
-
-    /* LOCK */
-    pthread_mutex_lock(&pdp_pool_mutex);
-
-    for (i=0; i < pdp_pool_size; i++){
-	p = pdp_pool[i];
-	if(p && !p->users) {
-	    _pdp_packet_dealloc(p);
-	    pdp_pool[i] = 0;
-	}
-    }
-    nbpackets -= pdp_packet_count;
-    //post("pdp_pool_collect_garbage: deleted %d unused packets", nbpackets);
-
-    /* UNLOCK */
-    pthread_mutex_unlock(&pdp_pool_mutex);
-
-    return nbpackets;
-}
-
-void
-pdp_pool_set_max_mem_usage(int max)
-{
-    if (max < 0) max = 0;
-    pdp_packet_max_mem_usage = max;
-    
-}
-
-
-
-
-
-
-/* malloc wrapper that calls garbage collector */
-void *pdp_alloc(int size)
-{
-    void *ptr = malloc(size);
-    
-    //post ("malloc called for %d bytes", size);
-
-    if (ptr) return ptr;
-
-    post ("malloc failed in a pdp module: running garbage collector.");
-
-    pdp_pool_collect_garbage();
-    return malloc(size);
-}
-
-
-void pdp_dealloc(void *stuff)
-{
-    free (stuff);
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_packet2.c b/system/kernel/pdp_packet2.c
deleted file mode 100644
index 3717a77..0000000
--- a/system/kernel/pdp_packet2.c
+++ /dev/null
@@ -1,623 +0,0 @@
-/*
- *   Pure Data Packet system implementation: Packet Manager
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-
-#include <stdio.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <string.h>
-#include "pdp_post.h"
-#include "pdp_packet.h"
-#include "pdp_mem.h"
-#include "pdp_list.h"
-#include "pdp_type.h"
-#include "pdp_debug.h"
-
-
-/* packet implementation. contains class and packet (instance) handling 
-
-   some notes on packet operations.
-   copy ro/rw and unregister are relatively straightforward
-   packet creation can be done in 2 ways in this interface:
-     create + reuse
-   however, these methods should only be called by specific factory
-   methods, so the user should only create packets using pdp_factory_newpacket
-
-   reuse or create is thus the responsability of the factory methods for
-   each packet type (class) implementation
-
-
-*/
-
-
-/* NOTE:
-   the packet pool methods are called within the pool locks. this probably
-   needs to change, because it will cause deadlocks for container packets (fobs) */
-
-
-/* new implementation: probably just a minor adjustment: add the reuse fifo attached
-   to type desc symbol name
-   need to check and possibly eliminate hacks for non-pure packets
-
-   pdp_packet_new:
-      LOCK
-      1. check reuse fifo
-      2. empty -> create packet+return (search array)
-      3. element -> check if type is correct, yes->pop+return, no->goto 1.
-      UNLOCK
-      4. wakeup
-
-   pdp_packet_mark_unused
-      
-      1. check refcount. if > 1 dec  + exit
-      2. if 1 put packet to sleep 
-      3. dec refcount
-      4. add to reuse fifo (no fifo -> create)
-
-   pdp_packet_delete: analogous to mark_unused
-   pdp_packet_copy_ro/rw: analogous to new
-
-*/      
-
-
-/* the pool */
-#define PDP_INITIAL_POOL_SIZE 64
-static int pdp_pool_size;
-static t_pdp** pdp_pool;
-
-/* mutex: protects the pool and reuse lists attached to symbols */
-static pthread_mutex_t pdp_pool_mutex;
-#define LOCK   pthread_mutex_lock   (&pdp_pool_mutex)
-#define UNLOCK pthread_mutex_unlock (&pdp_pool_mutex)
-
-/* the list of classes */
-static t_pdp_list *class_list;
-
-/* debug */
-void
-pdp_packet_print_debug(int packet)
-{
-    t_pdp *h = pdp_packet_header(packet);
-    pdp_post("debug info for packet %d", packet);
-    if (!h){
-	pdp_post("invalid packet");
-    }
-    else{
-	pdp_post ("\ttype: %d", h->type);
-	pdp_post ("\tdesc: %s", h->desc ? h->desc->s_name : "unknown");
-	pdp_post ("\tsize: %d", h->size);
-	pdp_post ("\tflags: %x", h->flags);
-	pdp_post ("\tusers: %d", h->users);
-	pdp_post ("\tclass: %x", h->theclass);
-    }
-}
-
-
-
-/* setup methods */
-
-void 
-pdp_packet_setup(void)
-{
-
-    pdp_pool_size = PDP_INITIAL_POOL_SIZE;
-    pdp_pool = (t_pdp **)pdp_alloc(PDP_INITIAL_POOL_SIZE * sizeof(t_pdp *));
-    bzero(pdp_pool, pdp_pool_size * sizeof(t_pdp *));
-    class_list = pdp_list_new(0);
-    pthread_mutex_init(&pdp_pool_mutex, NULL);
-}
-
-/* class methods */
-t_pdp_class *pdp_class_new(t_pdp_symbol *type, t_pdp_factory_method create){
-    t_pdp_class *c = (t_pdp_class *)pdp_alloc(sizeof(t_pdp_class));
-    memset(c, 0, sizeof(t_pdp_class));
-    c->create = create;
-    c->type = type; // set type
-    pdp_list_add(class_list, a_pointer, (t_pdp_word)((void *)c));
-    return c;
-}
-
-/* the packet factory */
-int pdp_factory_newpacket(t_pdp_symbol *type)
-{
-    int p;
-    t_pdp_class *c;
-    t_pdp_atom *a = class_list->first;
-
-    /* try to reuse first 
-       THINK: should this be the responsability of the type specific constructors,
-       or should a packet allways be reusable (solution: depends on what the cleanup method returns??)
-     */
-    p = pdp_packet_reuse(type);
-    if (-1 != p) return p;
-
-
-    /* call class constructor */
-    while(a){
-	c = (t_pdp_class *)(a->w.w_pointer);
-	if (c->type && pdp_type_description_match(type, c->type)){
-	    //pdp_post("method %x, type %s", c->create, type->s_name);
-	    return (c->create) ? (*c->create)(type) : -1;
-	}
-	a = a->next;
-    }
-    return -1;
-}
-
-static void
-_pdp_pool_expand_nolock(void){
-    int i;
-
-    /* double the size */
-    int new_pool_size = pdp_pool_size << 1;
-    t_pdp **new_pool = (t_pdp **)pdp_alloc(new_pool_size * sizeof(t_pdp *));
-    bzero(new_pool, new_pool_size * sizeof(t_pdp *));
-    memcpy(new_pool, pdp_pool, pdp_pool_size * sizeof(t_pdp *));
-    pdp_dealloc(pdp_pool);
-    pdp_pool = new_pool;
-    pdp_pool_size = new_pool_size;
-}
-
-
-
-
-/* private _pdp_packet methods */
-
-/* packets can only be created and destroyed using these 2 methods */
-/* it updates the mem usage and total packet count */
-
-static void
-_pdp_packet_dealloc_nolock(t_pdp *p)
-{
-    /* free memory */
-    pdp_dealloc (p);
-}
-
-static t_pdp*
-_pdp_packet_alloc_nolock(unsigned int datatype, unsigned int datasize)
-{
-    unsigned int totalsize = datasize + PDP_HEADER_SIZE;
-    t_pdp *p = (t_pdp *)pdp_alloc(totalsize);
-    if (p){
-	memset(p, 0, PDP_HEADER_SIZE); //initialize header to 0
-	p->type = datatype;
-	p->size = totalsize;
-	p->users = 1;
-    }
-    return p;
-}
-
-
-/* create a new packet and expand pool if necessary */
-static int
-_pdp_packet_create_nolock(unsigned int datatype, unsigned int datasize)
-{
-    int p = 0;
-    while(1){
-	for (; p < pdp_pool_size; p++){
-	    if (!pdp_pool[p]){
-		/* found slot to store packet*/
-		t_pdp *header = _pdp_packet_alloc_nolock(datatype, datasize);
-		if (!header) return -1; // error allocating packet
-		pdp_pool[p] = header;
-		return p;
-	    }
-	}
-	/* no slot found, expand pool */
-	_pdp_pool_expand_nolock();
-    }
-}
-
-
-void 
-pdp_packet_destroy(void)
-{
-    int i = 0;
-    /* dealloc all the data in object stack */
-    pdp_post("DEBUG: pdp_packet_destroy: clearing object pool.");
-    while ((i < pdp_pool_size) && (pdp_pool[i])) _pdp_packet_dealloc_nolock(pdp_pool[i++]);
-}
-
-
-
-
-
-
-
-
-/* public pool operations: have to be thread safe so each entry point
-   locks the mutex */
-
-
-/* create a new packet.
-   this should only be used by type specific factory methods, and only if the
-   reuse method fails, since it will always create a new packet */
-int 
-pdp_packet_create(unsigned int datatype, unsigned int datasize /*without header*/)
-{
-    int packet;
-    LOCK;
-    packet = _pdp_packet_create_nolock(datatype, datasize);
-    UNLOCK;
-    return packet;
-}
-
-
-/* return a new packet.
-   it tries to reuse a packet based on
-    1. matching data size
-    2. abscence of destructor (which SHOULD mean there are no enclosed references)
-
-    it obviously can't use the reuse fifo tagged to a symbolic type description
-
-    ALWAYS USE pdp_packet_reuse BEFORE calling pdp_packet_new if possible
-    use both ONLY IN CONSTRUCTORS !!!
-
-    use pdp_packet_factory to create packets as a "user"
-
-    this is a summary of all internal packet creation mechanisms:
-
-     -> pdp_packet_reuse, which uses symbolic type descriptions, and should work for all packet types
-        it returns an initialized container (meta = correct, data = garbage)
-
-     -> pdp_packet_new, which only works for non-pure packets, and reuses packets based on data type
-        it returns a pure packet (meta + data = garbage)
-
-     -> pdp_packet_create, like pdp_packet_new, only it always creates a new packet
-
-
-
-*/
-
-int 
-pdp_packet_new(unsigned int datatype, unsigned int datasize)
-{
-    t_pdp *header;
-    int packet;
-    LOCK;
-    for (packet = 0; packet < pdp_pool_size; packet++){
-	header = pdp_pool[packet];
-	/* check data size */
-	if (header 
-	    && header->users == 0 
-	    && header->size == datasize + PDP_HEADER_SIZE
-	    && !(header->theclass && header->theclass->cleanup)){
-
-	    /* ok, got one. initialize */
-	    memset(header, 0, PDP_HEADER_SIZE);
-	    header->users = 1;
-	    header->type = datatype;
-	    header->size = datasize + PDP_HEADER_SIZE;
-
-	    UNLOCK; //EXIT1
-	    return packet;
-	}
-    }
-
-    /* no usable non-pure packet found, create a new one */
-
-    UNLOCK; //EXIT2
-    return pdp_packet_create(datatype, datasize);
-
-
-
-}
-
-
-/* internal method to add a packet to a packet type
-   description symbol's unused packet fifo */
-void
-_pdp_packet_save_nolock(int packet)
-{
-    t_pdp *header = pdp_packet_header(packet);
-    t_pdp_symbol *s;
-    PDP_ASSERT(header);
-    PDP_ASSERT(header->users == 0);
-    PDP_ASSERT(header->desc);
-    s = header->desc;
-    if (!s->s_reusefifo) s->s_reusefifo = pdp_list_new(0);
-    pdp_list_add(s->s_reusefifo, a_packet, (t_pdp_word)packet);
-}
-
-/* this will revive a packet matching a certain type description
-   no wildcards are allowed */
-int
-pdp_packet_reuse(t_pdp_symbol *type_description)
-{
-    int packet = -1;
-    t_pdp *header = 0;
-    t_pdp_list *l = 0;
-    LOCK;
-    if (!type_description || !(l = type_description->s_reusefifo)) goto exit;
-    while(l->elements){
-	packet = pdp_list_pop(l).w_packet;
-	header = pdp_packet_header(packet);
-
-	/* check if reuse fifo is consistent (packet unused + correct type)
-	   packet could be deleted and replaced with another one, or
-	   revived without the index updated (it's a "hint cache") */
-
-	if (header->users == 0){
-	    /* check if type matches */
-	    if (pdp_type_description_match(header->desc, type_description)){
-		header->users++; // revive
-		goto exit;
-	    }
-	    /* if not, add the packet to the correct reuse fifo */
-	    else{
-		_pdp_packet_save_nolock(packet);
-	    }
-	}
-
-	/* remove dangling refs */
-	header = 0;
-	packet = -1;
-    }
-    
-  exit:
-    UNLOCK;
-    if (header && header->theclass && header->theclass->wakeup){
-	header->theclass->wakeup(header); // revive if necessary
-    }
-    return packet;
-}
-
-/* find all unused packets in pool, marked as used (to protect from other reapers)
-   and return them as a list. non-pure packets are not revived */
-
-
-
-
-
-/* this returns a copy of a packet for read only access. 
-   (increases refcount of the packet -> packet will become readonly if it was
-   writable, i.e. had rc=1 */
-
-int
-pdp_packet_copy_ro(int handle)
-{
-    t_pdp* header;
-
-    if (header = pdp_packet_header(handle)){
-	PDP_ASSERT(header->users); // consistency check
-	LOCK;
-	header->users++;           // increment reference count
-	UNLOCK;
-    }
-    else handle = -1;
-    return handle;
-}
-
-/* clone a packet: create a new packet with the same
-   type as the source packet */
-
-int
-pdp_packet_clone_rw(int handle)
-{
-    t_pdp* header;
-    int new_handle = -1;
-
-
-    if (header = pdp_packet_header(handle)){
-	/* consistency checks */
-	PDP_ASSERT(header->users);
-	PDP_ASSERT(header->desc);
-
-	/* first try to reuse old packet */
-	new_handle = pdp_packet_reuse(header->desc);
-
-	/* if this failed, create a new one using the central packet factory method */
-	if (-1 == new_handle) new_handle = pdp_factory_newpacket(header->desc);
-    }
-
-    return new_handle;
-}
-
-/* return a copy of a packet (clone + copy data) */
-int
-pdp_packet_copy_rw(int handle)
-{
-    t_pdp *header, *new_header;
-    int new_handle = -1;
-
-    if (!(header = pdp_packet_header(handle))) return -1;
-
-    /* check if we are allowed to copy */
-    if (header->flags & PDP_FLAG_DONOTCOPY) return -1;
-
-    /* get target packet */
-    new_handle = pdp_packet_clone_rw(handle);
-    if (-1 == new_handle) return -1;
-    new_header = pdp_packet_header(new_handle);
-
-    /* if there is a copy method, use that one */
-    if (header->theclass && header->theclass->copy){
-	header->theclass->copy(header, new_header);
-    }
-
-    /* otherwize copy the data verbatim */
-    else {
-	memcpy(pdp_packet_data(new_handle),
-	       pdp_packet_data(handle),
-	       pdp_packet_data_size(handle));
-    }
-
-    return new_handle;
-    
-}
-
-
-/* decrement refcount */
-void pdp_packet_mark_unused(int handle)
-{
-    t_pdp *header;
-    if (!(header = pdp_packet_header(handle))) return;
-    
-    PDP_ASSERT(header->users); // consistency check
-
-    LOCK;
-
-    /* just decrement refcount */
-    if (header->users > 1){
-	header->users--;
-    }
-
-    /* put packet to sleep if refcount 1->0 */
-    else {
-	if (header->theclass && header->theclass->sleep){
-	    /* call sleep method (if any) outside of lock
-	       while the packet is still alive, so it won't be
-	       acclaimed by another thread */
-	    UNLOCK;
-	    header->theclass->sleep(header); 
-	    LOCK;
-	}
-	/* clear refcount & save in fifo for later use */
-	header->users = 0;
-	if (header->desc) // sleep could have destructed packet..
-	    _pdp_packet_save_nolock(handle);
-    }
-
-    UNLOCK;
-}
-
-
-
-/* delete a packet. rc needs to be == 1 */
-void pdp_packet_delete(int handle)
-{
-    t_pdp *header;
-    header = pdp_packet_header(handle);
-    PDP_ASSERT(header);
-    PDP_ASSERT(header->users == 1); // consistency check
-
-    LOCK;
-    
-    if (header->theclass && header->theclass->cleanup){
-	/* call cleanup method (if any) outside of lock
-	   while the packet is still alive, so it won't be
-	   acclaimed by another thread */
-	UNLOCK;
-	header->theclass->cleanup(header); 
-	LOCK;
-    }
-
-    /* delete the packet */
-    pdp_pool[handle] = 0;
-    _pdp_packet_dealloc_nolock(header);
-    
-
-    UNLOCK;
-}
-
-
-
-
-
-
-
-/* public data access methods */
-
-t_pdp*
-pdp_packet_header(int handle)
-{
-    if ((handle >= 0) && (handle < pdp_pool_size)) return pdp_pool[handle];
-    else return 0;
-}
-
-void*
-pdp_packet_subheader(int handle)
-{
-    t_pdp* header = pdp_packet_header(handle);
-    if (!header) return 0;
-    return (void *)(&header->info.raw);
-}
-
-void*
-pdp_packet_data(int handle)
-{
-    t_pdp *h;
-    if ((handle >= 0) && (handle < pdp_pool_size)) 
-	{
-	    h = pdp_pool[handle];
-	    if (!h) return 0;
-	    return (char *)(h) + PDP_HEADER_SIZE;
-	}
-    else return 0;
-}
-
-int
-pdp_packet_data_size(int handle)
-{
-    t_pdp *h;
-    if ((handle >= 0) && (handle < pdp_pool_size)) 
-	{
-	    h = pdp_pool[handle];
-	    if (!h) return 0;
-	    return h->size - PDP_HEADER_SIZE;
-	}
-    else return 0;    
-}
-
-
-
-
-int pdp_packet_writable(int packet) /* returns true if packet is writable */
-{
-    t_pdp *h = pdp_packet_header(packet);
-    if (!h) return 0;
-    return (h->users == 1);
-}
-
-void pdp_packet_replace_with_writable(int *packet) /* replaces a packet with a writable copy */
-{
-    int new_p;
-    if (!pdp_packet_writable(*packet)){
-	new_p = pdp_packet_copy_rw(*packet);
-	pdp_packet_mark_unused(*packet);
-	*packet = new_p;
-    }
-	
-}
-
-/* pool stuff */
-
-int
-pdp_pool_collect_garbage(void)
-{
-    pdp_post("ERROR: garbage collector not implemented");
-    return 0;
-}
-
-void
-pdp_pool_set_max_mem_usage(int max)
-{
-    pdp_post("ERROR: mem limit not implemented");
-}
-
-
-
-
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_post.c b/system/kernel/pdp_post.c
deleted file mode 100644
index fb761d0..0000000
--- a/system/kernel/pdp_post.c
+++ /dev/null
@@ -1,48 +0,0 @@
-
-/*
- *   Pure Data Packet system file. pdp logging.
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include "pdp_post.h"
-
-/* list printing should be moved here too */
-
-/* write a message to log (console) */
-void pdp_post_n(char *fmt, ...)
-{
-    va_list ap;
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-}
-void pdp_post(char *fmt, ...)
-{
-    va_list ap;
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-    putc('\n', stderr);
-}
-
-
diff --git a/system/kernel/pdp_queue.c b/system/kernel/pdp_queue.c
deleted file mode 100644
index 665a236..0000000
--- a/system/kernel/pdp_queue.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
- *   Pure Data Packet - processor queue module.
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-
-/* 
-   this is a the processor queue pdp system module 
-   it receives tasks from objects that are schedules to 
-   be computed in another thread. the object is signalled back
-   when the task is completed.
-
-   this is not a standard pd class. it is a sigleton class
-   using a standard pd clock to poll for compleded methods on 
-   every scheduler run. this is a hack to do thread synchronization 
-   in a thread unsafe pd.
-
-   the queue object can be reused. the pdp system however only
-   has one instance (one pdp queue. pdp remains a serial program.)
-
- */
-
-#include "pdp.h"
-#include <pthread.h>
-#include <unistd.h>
-#include <stdio.h>
-
-
-#define D if (0)
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#define PDP_QUEUE_LOGSIZE 10
-#define PDP_QUEUE_DELTIME 10.0f
-
-
-
-
-/********************* general purpose pd process queue class *********************/
-
-void pdp_procqueue_wait(t_pdp_procqueue *q)
-{
-    D post("pdp_procqueue_wait(%x): waiting for pdp_queue_thread to finish processing", q);
-    pthread_mutex_lock(&q->mut);
-    while(((q->curr - q->head) & q->mask) != 0){
-
-	  pthread_cond_wait(&q->cond_processingdone, &q->mut);
-    }
-    pthread_mutex_unlock(&q->mut);
-    D post("pdp_procqueue_wait(%x): pdp_procqueue_thread has finished processing", q);
-
-}
-void pdp_procqueue_finish(t_pdp_procqueue *q, int index)
-{
-
-  if (-1 == index) {
-      //post("pdp_pq_remove: index == -1");
-      return;
-  }
-  /* wait for processing thread to finish*/
-  pdp_procqueue_wait(q);
-
-  /* invalidate callback at index */
-  q->q[index & q->mask].x_callback = 0;
-  q->q[index & q->mask].x_queue_id = 0;
-
-}
-
-static void pdp_procqueue_signal_processor(t_pdp_procqueue *q)
-{
-
-    //NOTE: uncommenting these post statements causes a libc crash
-    //in mutex lock in putc
-    //D post("pdp_procqueue_signal_processor(%x): signalling process thread", q);
-    pthread_mutex_lock(&q->mut);
-    pthread_cond_signal(&q->cond_dataready);
-    pthread_mutex_unlock(&q->mut);
-    //D post("pdp_procqueue_signal_processor(%x): signalling done", q);
-
-
-}
-
-static void pdp_procqueue_wait_for_feeder(t_pdp_procqueue *q)
-{
-
-
-    /* only use locking when there is no data */
-    if(((q->curr - q->head) & q->mask) == 0){
-
-	/* signal processing done */
-	D post("pdp_procqueue_wait_for_feeder(%x): signalling processing is done", q);
-	pthread_mutex_lock(&q->mut);
-	pthread_cond_signal(&q->cond_processingdone);
-
-	/* wait until there is an item in the queue */
-	while(((q->curr - q->head) & q->mask) == 0){
-	    pthread_cond_wait(&q->cond_dataready, &q->mut);
-	}
-
-	pthread_mutex_unlock(&q->mut);
-	D post("pdp_procqueue_wait_for_feeder(%x): waiting done", q);
-
-    }
-}
-
-void pdp_procqueue_add(t_pdp_procqueue *q, void *owner, void *process, void *callback, int *queue_id)
-{
-    int i;
-
-    /* if processing is in not in thread, just call the funcs */
-    if (!q->use_thread){
-	D post("pdp_procqueue_add(%q): calling processing routine directly", q);
-	if (queue_id) *queue_id = -1;
-	if (process)  ((t_pdpmethod) process)(owner);
-	if (callback) ((t_pdpmethod) callback)(owner);
-	return;
-    }
-	
-
-    /* if queue is full, call directly */
-    if (1 == ((q->tail - q->head) & q->mask)) {
-	//post("pdp_procqueue_add: WARNING: processing queue (%x) is full.\n", q);
-	//post("pdp_procqueue_add: WARNING: tail %x, head %x, mask %x.\n", q->tail, q->head, q->mask);
-	//post("pdp_procqueue_add: WARNING: skipping process method, calling callback directly.\n");
-	if (queue_id) *queue_id = -1;
-	if (callback) ((t_pdpmethod) callback)(owner);
-	return;
-	//exit(1);
-    }
-
-    /* schedule method in thread queue */
-    i = q->head & q->mask;
-    q->q[i].x_owner = owner;
-    q->q[i].x_process = process;
-    q->q[i].x_callback = callback;
-    q->q[i].x_queue_id = queue_id;
-    if (queue_id) *queue_id = i;
-    //post("pdp_queue_add: added method to queue, index %d", i);
-
-      
-    // increase the packet count
-    q->packets++;
-  
-    // move head forward
-    q->head++;
-
-    pdp_procqueue_signal_processor(q);
-
-}
-
-
-/* processing thread */
-static void *pdp_procqueue_thread(void *vq)
-{
-    t_pdp_procqueue *q = (t_pdp_procqueue *)vq;
-
-    D post("pdp_procqueue_thread(%x): thread started", q);
-
-    while(1){
-	t_process_queue_item *p;
-
-
-	D post("pdp_procqueue_thread(%x): waiting for feeder", q);
-
-	/* wait until there is data available */
-	pdp_procqueue_wait_for_feeder(q);      
-
-
-	D post("pdp_procqueue_thread(%x): processing %d", q, q->curr & q->mask);
-
-	
-	/* call the process routine */
-	p = &q->q[q->curr & q->mask];
-	if (p->x_process) 
-	    (p->x_process)(p->x_owner);
-
-	/* advance */
-	q->curr++;
-
-
-    }
-}
-
-
-/* call back all the callbacks */
-static void pdp_procqueue_callback (t_pdp_procqueue *q)
-{
-
-  /* call callbacks for finished packets */
-  while(0 != ((q->curr - q->tail) & q->mask))
-    {
-      int i = q->tail & q->mask;
-      /* invalidate queue id */
-      if(q->q[i].x_queue_id) *q->q[i].x_queue_id = -1;
-      /* call callback */
-      if(q->q[i].x_callback) (q->q[i].x_callback)(q->q[i].x_owner);
-      //else post("pdp_pq_tick: callback %d is disabled",i );
-      q->tail++;
-    }
-
-}
-
-/* the clock method */
-static void pdp_procqueue_tick (t_pdp_procqueue *q)
-{
-  /* do work */
-  //if (!(ticks % 1000)) post("pdp tick %d", ticks);
-
-  if (!q->use_thread) return;
-
-  /* call callbacks */
-  pdp_procqueue_callback(q);
-
-  /* increase counter */
-  q->ticks++;
-
-  /* set clock for next update */
-  clock_delay(q->pdp_clock, q->deltime);
-}
-
-
-
-void pdp_procqueue_use_thread(t_pdp_procqueue* q, int t)
-{
-    /* if thread usage is being disabled, 
-       wait for thread to finish processing first */
-    if (t == 0) {
-	pdp_procqueue_wait(q);
-	q->use_thread = 0;
-	pdp_procqueue_callback(q);
-	clock_unset(q->pdp_clock);
-    }
-    else {
-	clock_unset(q->pdp_clock);
-	clock_delay(q->pdp_clock, q->deltime);
-	q->use_thread = 1;
-    }
-
-}
-
-void pdp_procqueue_init(t_pdp_procqueue *q, double milliseconds, int logsize)
-{
-    pthread_attr_t attr;
-    int size = 1 << logsize;
-
-    /* setup pdp queue processor object */
-    q->ticks = 0;
-    q->deltime = milliseconds;
-
-    /* setup queue data */
-    q->mask = size - 1;
-    q->head = 0;
-    q->tail = 0;
-    q->curr = 0;
-    q->q = pdp_alloc(size * sizeof(t_process_queue_item));
-    memset(q->q, 0, size * sizeof(t_process_queue_item));
-
-    /* enable threads */
-    q->use_thread = 1;
-
-    /* setup synchro stuff */
-    pthread_mutex_init(&q->mut, NULL);
-    pthread_cond_init(&q->cond_dataready, NULL);
-    pthread_cond_init(&q->cond_processingdone, NULL);
-
- 
-    /* allocate the clock */
-    q->pdp_clock = clock_new(q, (t_method)pdp_procqueue_tick);
-
-    /* set the clock */
-    clock_delay(q->pdp_clock, 0);
-
-    /* start processing thread */
-
-    /* glibc doc says SCHED_OTHER is default,
-       but it seems not to be when initiated from a RT thread
-       so we explicitly set it here */
-    pthread_attr_init (&attr);
-    //pthread_attr_setschedpolicy(&attr, SCHED_FIFO); 
-    pthread_attr_setschedpolicy(&attr, SCHED_OTHER); 
-
-    D post("pdp_procqueue_init(%x): starting thread", q);
-    pthread_create(&q->thread_id, &attr, pdp_procqueue_thread, (void *)q);
-    D post("pdp_procqueue_init(%x): back in pd thread", q);
-
-    /* wait for processing thread to finish */
-    //pdp_procqueue_wait(q);
-
-    /* set default disable/enable thread here */
-    //post("pdp_queue: THREAD PROCESSING ON BY DEFAULT!!");
-    pdp_procqueue_use_thread(q,0);
-
-}
-
-
-
-
-/* the (static) pdp queue object */
-static t_pdp_procqueue pdp_queue;
-
-
-/* get the default queue */
-t_pdp_procqueue *pdp_queue_get_queue(void){return &pdp_queue;}
-
-
-#if 1
-/* default pdp queue shortcut methods */
-void pdp_queue_wait() {pdp_procqueue_wait(&pdp_queue);}
-void pdp_queue_finish(int index) { pdp_procqueue_finish(&pdp_queue, index);}
-void pdp_queue_add(void *owner, void *process, void *callback, int *queue_id) {
-    pdp_procqueue_add(&pdp_queue, owner, process, callback, queue_id);
-}
-void pdp_queue_use_thread(int t) {pdp_procqueue_use_thread(&pdp_queue, t);}
-void pdp_queue_setup(void){
-    pdp_procqueue_init(&pdp_queue, PDP_QUEUE_DELTIME, PDP_QUEUE_LOGSIZE);
-    pdp_procqueue_use_thread(&pdp_queue,0);
-}
-#endif
-
-
-
-
-
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/system/kernel/pdp_symbol.c b/system/kernel/pdp_symbol.c
deleted file mode 100644
index 32e9e33..0000000
--- a/system/kernel/pdp_symbol.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- *   Pure Data Packet system implementation. : code implementing pdp's namespace (symbols)
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <string.h>
-#include <pthread.h>
-#include "pdp_symbol.h"
-#include "pdp_list.h"
-#include "pdp_debug.h"
-
-// some extra prototypes
-void *pdp_alloc(int size);
-void pdp_dealloc(void *data);
-
-// the symbol hash mutex
-static pthread_mutex_t pdp_hash_mutex;
-
-#define HASHSIZE 1024
-static t_pdp_symbol *pdp_symhash[HASHSIZE];
-
-
-#define LOCK pthread_mutex_lock(&pdp_hash_mutex)
-#define UNLOCK pthread_mutex_unlock(&pdp_hash_mutex)
-
-
-static void _pdp_symbol_init(t_pdp_symbol *s)
-{
-    memset(s, 0, sizeof(*s));
-    s->s_forth.t = a_undef;
-}
-
-
-/* shamelessly copied from pd src and made thread safe */
-t_pdp_symbol *_pdp_dogensym(char *s, t_pdp_symbol *oldsym)
-{
-    t_pdp_symbol **sym1, *sym2;
-    unsigned int hash1 = 0,  hash2 = 0;
-    int length = 0;
-    char *s2 = s;
-    while (*s2)
-    {
-        hash1 += *s2;
-        hash2 += hash1;
-        length++;
-        s2++;
-    }
-    sym1 = pdp_symhash + (hash2 & (HASHSIZE-1));
-
-    /* lock hash */
-    LOCK;
-
-    while (sym2 = *sym1)
-    {
-        if (!strcmp(sym2->s_name, s)) goto gotit;
-        sym1 = &sym2->s_next;
-    }
-    if (oldsym){
-	sym2 = oldsym;
-    }
-    else
-    {
-        sym2 = (t_pdp_symbol *)pdp_alloc(sizeof(*sym2));
-	_pdp_symbol_init(sym2);
-        sym2->s_name = pdp_alloc(length+1);
-        sym2->s_next = 0;
-        strcpy(sym2->s_name, s);
-    }
-    *sym1 = sym2;
-
- gotit:
-
-    /* unlock hash */
-    UNLOCK;
-    return (sym2);
-}
-
-t_pdp_symbol *pdp_gensym(char *s)
-{
-    return(_pdp_dogensym(s, 0));
-}
-
-
-/* connect a parsed typelist to a symbol type name
-   1 = succes, 0 = error (symbol already connected) */
-int pdp_symbol_set_typelist(t_pdp_symbol *s, t_pdp_list *typelist)
-{
-    int status = 0;
-    LOCK;
-    if (!s->s_type){
-	s->s_type = typelist;
-	status = 1;
-    }
-    UNLOCK;
-    return status;
-}
-
-
-void pdp_symbol_apply_all(t_pdp_symbol_iterator it)
-{
-    int i;
-    for (i=0; i<HASHSIZE; i++){
-	t_pdp_symbol *s;
-	for (s = pdp_symhash[i]; s; s=s->s_next){
-	    it(s);
-	}
-	
-    }
-}
-
-t_pdp_symbol _pdp_sym_wildcard;
-t_pdp_symbol _pdp_sym_float;
-t_pdp_symbol _pdp_sym_int;
-t_pdp_symbol _pdp_sym_symbol;
-t_pdp_symbol _pdp_sym_packet;
-t_pdp_symbol _pdp_sym_pointer;
-t_pdp_symbol _pdp_sym_invalid;
-t_pdp_symbol _pdp_sym_list;
-t_pdp_symbol _pdp_sym_question_mark;
-t_pdp_symbol _pdp_sym_atom;
-t_pdp_symbol _pdp_sym_null;
-t_pdp_symbol _pdp_sym_quote_start;
-t_pdp_symbol _pdp_sym_quote_end;
-t_pdp_symbol _pdp_sym_return;
-t_pdp_symbol _pdp_sym_nreturn;
-t_pdp_symbol _pdp_sym_defstart;
-t_pdp_symbol _pdp_sym_defend;
-t_pdp_symbol _pdp_sym_if;
-t_pdp_symbol _pdp_sym_then;
-t_pdp_symbol _pdp_sym_local;
-t_pdp_symbol _pdp_sym_forth;
-t_pdp_symbol _pdp_sym_call;
-t_pdp_symbol _pdp_sym_push;
-t_pdp_symbol _pdp_sym_pop;
-
-static void _sym(char *name, t_pdp_symbol *s)
-{
-    t_pdp_symbol *realsym;
-    _pdp_symbol_init(s);
-    s->s_name = name;
-    realsym = _pdp_dogensym(name, s); 
-    PDP_ASSERT(realsym == s); // if this fails, the symbol was already defined
-}
-
-void pdp_symbol_setup(void)
-{
-    // create mutexes
-    pthread_mutex_init(&pdp_hash_mutex, NULL);
-
-    // init symbol hash
-    memset(pdp_symhash, 0, HASHSIZE * sizeof(t_pdp_symbol *));
-
-    // setup predefined symbols (those that have direct pointer access for speedup)
-    _sym("*",        &_pdp_sym_wildcard);
-    _sym("float",    &_pdp_sym_float);
-    _sym("int",      &_pdp_sym_int);
-    _sym("symbol",   &_pdp_sym_symbol);
-    _sym("packet",   &_pdp_sym_packet);
-    _sym("pointer",  &_pdp_sym_pointer);
-    _sym("invalid",  &_pdp_sym_invalid);
-    _sym("list",     &_pdp_sym_list);
-    _sym("?",        &_pdp_sym_question_mark);
-    _sym("atom",     &_pdp_sym_atom);
-    _sym("null",     &_pdp_sym_null);
-    _sym("[",        &_pdp_sym_quote_start);
-    _sym("]",        &_pdp_sym_quote_end);
-    _sym("ret",      &_pdp_sym_return);
-    _sym("nret",     &_pdp_sym_nreturn);
-    _sym(":",        &_pdp_sym_defstart);
-    _sym(";",        &_pdp_sym_defend);
-    _sym("if",       &_pdp_sym_if);
-    _sym("then",     &_pdp_sym_then);
-    _sym("local",    &_pdp_sym_local);
-    _sym("forth",    &_pdp_sym_forth);
-    _sym("call",     &_pdp_sym_call);
-    _sym("push",     &_pdp_sym_push);
-    _sym("pop",      &_pdp_sym_pop);
-
-}
-
-
diff --git a/system/kernel/pdp_type.c b/system/kernel/pdp_type.c
deleted file mode 100644
index c220269..0000000
--- a/system/kernel/pdp_type.c
+++ /dev/null
@@ -1,501 +0,0 @@
-/*
- *   Pure Data Packet system implementation. : code for handling different packet types
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-/* this file contains type handling routines */
-
-#include <stdarg.h>
-#include <string.h>
-#include <pthread.h>
-#include "pdp.h"
-
-
-// debug
-#define D if (0)
-
-
-static t_pdp_list *conversion_list;
-
-#define INIT_MAX_CACHE_SIZE 32
-
-static t_pdp_list *cached_conversion_list;
-static int max_cache_size;
-
-/* mutex */
-static pthread_mutex_t pdp_hash_mutex;
-static pthread_mutex_t pdp_conversion_mutex;
-static pthread_mutex_t pdp_cache_mutex;
-
-#define HASHSIZE 1024
-static t_pdp_symbol *pdp_symhash[HASHSIZE];
-
-
-/* shamelessly copied from pd src and made thread safe */
-t_pdp_symbol *_pdp_dogensym(char *s, t_pdp_symbol *oldsym)
-{
-    t_pdp_symbol **sym1, *sym2;
-    unsigned int hash1 = 0,  hash2 = 0;
-    int length = 0;
-    char *s2 = s;
-    while (*s2)
-    {
-        hash1 += *s2;
-        hash2 += hash1;
-        length++;
-        s2++;
-    }
-    sym1 = pdp_symhash + (hash2 & (HASHSIZE-1));
-
-    /* lock hash */
-    pthread_mutex_lock(&pdp_hash_mutex);
-
-    while (sym2 = *sym1)
-    {
-        if (!strcmp(sym2->s_name, s)) goto gotit;
-        sym1 = &sym2->s_next;
-    }
-    if (oldsym) sym2 = oldsym;
-    else
-    {
-        sym2 = (t_pdp_symbol *)pdp_alloc(sizeof(*sym2));
-        sym2->s_name = pdp_alloc(length+1);
-	_pdp_symbol_clear_namespaces(sym2);
-        sym2->s_next = 0;
-        strcpy(sym2->s_name, s);
-    }
-    *sym1 = sym2;
-
- gotit:
-
-    /* unlock hash */
-    pthread_mutex_unlock(&pdp_hash_mutex);
-    return (sym2);
-}
-
-t_pdp_symbol *pdp_gensym(char *s)
-{
-    return(_pdp_dogensym(s, 0));
-}
-
-/* convert a type to a list */
-t_pdp_list *pdp_type_to_list(t_pdp_symbol *type)
-{
-    char *c = type->s_name;
-    char *lastname = c;
-    char tmp[100];
-    int n = 0;
-    t_pdp_list *l = pdp_list_new(0);
-
-    while(*c){
-	if (*c == '/'){
-	    strncpy(tmp, lastname, n);
-	    tmp[n] = 0;
-	    pdp_list_add_back(l, a_symbol, (t_pdp_word)pdp_gensym(tmp));
-	    c++;
-	    lastname = c;
-	    n = 0;
-	}
-	else{
-	    c++;
-	    n++;
-	}
-    }
-    pdp_list_add_back(l, a_symbol, (t_pdp_word)pdp_gensym(lastname));
-
-    return l;
-}
-
-
-/* get the description symbol. this includes some compat transition stuff with a warning */
-t_pdp_symbol *pdp_packet_get_description(int packet)
-{
-    t_pdp *header = pdp_packet_header(packet);
-
-    if (!header) return pdp_gensym("invalid");
-    else if (!header->desc){
-
-	post("ERROR: pdp_packet_get_description: packet %d has no description.", packet);
-	pdp_packet_print_debug(packet);
-	return pdp_gensym("unknown");
-    }
-    else return header->desc;
-}
-
-
-
-/* this runs a conversion program */
-int _pdp_type_run_conversion_program(t_pdp_conversion_program *program,
-	 			    int packet, t_pdp_symbol *dest_template)
-{
-    /* run a conversion program:
-       treat the source packet as readonly, and cleanup intermediates, such
-       that the net result is the production of a new packet, with the
-       source packet intact. */
-
-    int p, tmp;
-    t_pdp_atom *a;
-    t_pdp_conversion_method m;
-
-    // run the first line of the program
-    a = program->first;
-    m = a->w.w_pointer;
-    D post("DEBUG: _pdp_type_run_conversion_program: method = %x", m);
-    p = m(packet, dest_template);
-    D post("DEBUG: _pdp_type_run_conversion_program: packet returned = %d, type = %s", p, pdp_packet_get_description(p)->s_name);
-
-    // run the remaining lines + cleanup intermediates
-    for (a=a->next; a; a=a->next){
-	m = a->w.w_pointer;
-	D post("DEBUG: _pdp_type_run_conversion_program: next method ptr = %x", m);
-	tmp = m(p, dest_template);
-	pdp_packet_mark_unused(p);
-	p = tmp;
-    }
-    return p;
-}
-
-
-/* find a conversion program */
-t_pdp_conversion_program *
-_pdp_type_find_conversion_program(t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern)
-{
-    t_pdp_conversion *c;
-    t_pdp_atom *a;
-    t_pdp_conversion_program *retval = 0;
-
-    /* lock conversion list */
-    pthread_mutex_lock(&pdp_conversion_mutex);
-
-    for (a = conversion_list->first; a; a=a->next){
-	c = a->w.w_pointer;
-	/* can be a wildcard match */
-	if (pdp_type_description_match(src_pattern, c->src_pattern) &&
-	    pdp_type_description_match(dst_pattern, c->dst_pattern)) {
-	    /* found a program */
-	    D post("DEBUG: _pdp_type_find_conversion_program: found: %s -> %s", c->src_pattern->s_name, c->dst_pattern->s_name);
-	    retval = c->program;
-	    goto gotit;
-	}
-    }
-
-    /* no conversion program was found */
-    retval = 0;
- gotit:
-
-    /* lock conversion list */
-    pthread_mutex_unlock(&pdp_conversion_mutex);
-    return retval;
-}
-
-/* find a cached conversion program 
- if one is found it will be moved to the back of the queue (MRU) */
-t_pdp_conversion_program *
-_pdp_type_find_cached_conversion_program(t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern)
-{
-    t_pdp_conversion *c, *c_tmp;
-    t_pdp_atom *a;
-    t_pdp_conversion_program *retval = 0;
-
-    /* lock cached list */
-    pthread_mutex_lock(&pdp_cache_mutex);
-
-    for (a = cached_conversion_list->first; a; a=a->next){
-	c = a->w.w_pointer;
-	/* must be exact match */
-	if ((src_pattern == c->src_pattern) &&
-	    (dst_pattern == c->dst_pattern)) {
-
-	    /* found a program */
-	    D post("DEBUG: _pdp_type_find_cached_conversion_program: found: %s -> %s", c->src_pattern->s_name, c->dst_pattern->s_name);
-	    retval = c->program;
-
-	    /* make MRU (move to back) */
-	    c_tmp = cached_conversion_list->last->w.w_pointer;
-	    cached_conversion_list->last->w.w_pointer = c;
-	    a->w.w_pointer = c_tmp;
-	    goto gotit;
-	}
-    }
-
-    retval = 0;
-
- gotit:
-
-
-    /* un lock cached list */
-    pthread_mutex_unlock(&pdp_cache_mutex);
-
-    /* no conversion program was found */
-    return retval;
-}
-
-
-/* conversion program manipulations */
-void pdp_conversion_program_free(t_pdp_conversion_program *program)
-{
-    pdp_list_free(program);
-}
-
-/* debug print */
-void _pdp_conversion_program_print(t_pdp_conversion_program *program)
-{
-    post("_pdp_conversion_program_print %x", program);
-    pdp_list_print(program);
-}
-
-t_pdp_conversion_program *pdp_conversion_program_new(t_pdp_conversion_method method, ...)
-{
-    t_pdp_conversion_program *p = pdp_list_new(0);
-    t_pdp_conversion_method m = method;
-    va_list ap;
-
-    D post("DEBUG: pdp_conversion_program_new:BEGIN");
-
-    pdp_list_add_back_pointer(p, m);
-    va_start(ap, method);
-    while (m = va_arg(ap, t_pdp_conversion_method)) pdp_list_add_back_pointer(p, m);
-    va_end(ap);
-
-    D post("DEBUG: pdp_conversion_program_new:END");
- 
-    return p;
-}
-
-t_pdp_conversion_program *pdp_conversion_program_copy(t_pdp_conversion_program *program)
-{
-    if (program) return pdp_list_copy(program);
-    else return 0;
-}
-
-void pdp_conversion_program_add(t_pdp_conversion_program *program, t_pdp_conversion_program *tail)
-{ 
-    return pdp_list_cat(program, tail);
-}
-
-/* conversion registration */
-void pdp_type_register_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program)
-{
-    t_pdp_conversion *c = (t_pdp_conversion *)pdp_alloc(sizeof(*c));
-    c->src_pattern = src_pattern;
-    c->dst_pattern = dst_pattern;
-    c->program = program;
-
-    /* lock conversion list */
-    pthread_mutex_lock(&pdp_conversion_mutex);
-
-    pdp_list_add_back_pointer(conversion_list, c);
-
-    /* unlock conversion list */
-    pthread_mutex_unlock(&pdp_conversion_mutex);
-    
-}
-
-/* register a cached conversion */
-void pdp_type_register_cached_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program)
-{
-
-    /* create the new conversion */
-    t_pdp_conversion *c = (t_pdp_conversion *)pdp_alloc(sizeof(*c));
-    c->src_pattern = src_pattern;
-    c->dst_pattern = dst_pattern;
-    c->program = program;
-
-    /* lock cached conversion list */
-    pthread_mutex_lock(&pdp_cache_mutex);
-
-    /* check size, and remove LRU (top) if the cache is full */
-    while (cached_conversion_list->elements >= max_cache_size){
-	t_pdp_conversion *c_old = pdp_list_pop(cached_conversion_list).w_pointer;
-	if (c_old->program) pdp_conversion_program_free(c_old->program);
-	pdp_dealloc(c_old);
-    }
-    
-    /* add and make MRU (back) */
-    pdp_list_add_back_pointer(cached_conversion_list, c);
-
-    /* unlock cached conversion list */
-    pthread_mutex_unlock(&pdp_cache_mutex);
-}
-
-/* convert a given packet to a certain type (template) */
-int _pdp_packet_convert(int packet, t_pdp_symbol *dest_template)
-{
-    t_pdp_symbol *type = pdp_packet_get_description(packet);
-    t_pdp_symbol *tmp_type = 0;
-    int tmp_packet = -1;
-
-    t_pdp_conversion_program *program = 0;
-    t_pdp_conversion_program *program_last = 0;
-    t_pdp_conversion_program *program_tail = 0;
-
-    /* check if there is a program in the cached list, if so run it */
-    if (program = _pdp_type_find_cached_conversion_program(type, dest_template))
-	return _pdp_type_run_conversion_program(program, packet, dest_template);
-
-    /* if it is not cached, iteratively convert 
-       and save program on top of cache list if a conversion path (program) was found */
-
-    // run first conversion that matches
-    program = pdp_conversion_program_copy(_pdp_type_find_conversion_program(type, dest_template));
-    program_last = program;
-    if (!program){
-	D post("DEBUG: pdp_type_convert: (1) can't convert %s to %s", type->s_name, dest_template->s_name);
-	return -1;
-    }
-    tmp_packet = _pdp_type_run_conversion_program(program, packet, dest_template);
-    tmp_type = pdp_packet_get_description(tmp_packet);
-
-    // run more conversions if necessary, deleting intermediate packets
-    while (!pdp_type_description_match(tmp_type, dest_template)){
-	int new_packet;
-	program_tail = _pdp_type_find_conversion_program(tmp_type, dest_template);
-	if (!program_tail){
-	    D post("DEBUG: pdp_type_convert: (2) can't convert %s to %s", tmp_type->s_name, dest_template->s_name);
-	    pdp_packet_mark_unused(tmp_packet);
-	    pdp_conversion_program_free(program);
-	    return -1;
-	}
-	if (program_last == program_tail){
-	    post("ERROR: pdp_packet_convert: conversion loop detected");
-	}
-	program_last = program_tail;
-
-	pdp_conversion_program_add(program, program_tail);
-	new_packet = _pdp_type_run_conversion_program(program_tail, tmp_packet, dest_template);
-	pdp_packet_mark_unused(tmp_packet);
-	tmp_packet = new_packet;
-	tmp_type = pdp_packet_get_description(tmp_packet);
-    }
-
-    // save the conversion program
-    pdp_type_register_cached_conversion(type, dest_template, program);
-
-    // return resulting packet
-    return tmp_packet;
-	
-}
-
-/* convert or copy ro */
-int pdp_packet_convert_ro(int packet, t_pdp_symbol *dest_template)
-{
-    t_pdp_symbol *type = pdp_packet_get_description(packet);
-
-    /* if it is compatible, return a ro copy */
-    if (pdp_type_description_match(type, dest_template)) return pdp_packet_copy_ro(packet);
-
-    /* if not, convert to a new type */
-    else return _pdp_packet_convert(packet, dest_template);
-}
-
-/* convert or copy rw */
-int pdp_packet_convert_rw(int packet, t_pdp_symbol *dest_template)
-{
-    t_pdp_symbol *type = pdp_packet_get_description(packet);
-
-    /* if it is compatible, just return a rw copy */
-    if (pdp_type_description_match(type, dest_template)) return pdp_packet_copy_rw(packet);
-
-    /* if not, convert to a new type */
-    else return _pdp_packet_convert(packet, dest_template);
-}
-
-
-static void _setup_type_cache(t_pdp_symbol *s)
-{
-    t_pdp_list *l = pdp_type_to_list(s); 
-    pthread_mutex_lock(&pdp_hash_mutex); //lock to prevent re-entry
-    if (!s->s_type){
-	s->s_type = l;
-	l = 0;
-    }
-    pthread_mutex_unlock(&pdp_hash_mutex);
-    if (l) pdp_list_free(l);
-}
-
-/* check if a type description fits a template
-   this function is symmetric */
-int pdp_type_description_match(t_pdp_symbol *description, t_pdp_symbol *pattern)
-{
-    int retval = 0;
-
-    t_pdp_atom *ad, *ap;
-    t_pdp_symbol *wildcard = pdp_gensym("*");
-
-
-    if (!(pattern)) post("PANICA");
-    if (!(description)) post("PANICB");
-
-
-    /* same type -> match */
-    if (description == pattern) {retval = 1; goto done;}
-
-    /* use the description list stored in the symbol for comparison */
-    if (!(description->s_type)) _setup_type_cache(description);
-    if (!(pattern->s_type)) _setup_type_cache(pattern);
-
-    if (!(pattern->s_type)) post("PANIC1");
-    if (!(description->s_type)) post("PANIC2");
-
-    /* check size */
-    if (description->s_type->elements != pattern->s_type->elements){retval = 0;	goto done;}
-
-    /* compare symbols of type list */
-    for(ad=description->s_type->first, ap=pattern->s_type->first; ad; ad=ad->next, ap=ap->next){
-	if (ad->w.w_symbol == wildcard) continue;
-	if (ap->w.w_symbol == wildcard) continue;
-	if (ad->w.w_symbol != ap->w.w_symbol) {retval = 0; goto done;} /* difference and not a wildcard */
-    }
-
-    /* type templates match */
-    retval = 1;
-
- done:
-    D post("DEBUG: testing match between %s and %s: %s", 
-	   description->s_name, pattern->s_name, retval ? "match" : "no match");
-    return retval;
-
-}
-
-
-
-
-
-/* setup method */
-void pdp_type_setup(void)
-{
-    int i;
-
-    // create mutexes
-    pthread_mutex_init(&pdp_hash_mutex, NULL);
-    pthread_mutex_init(&pdp_conversion_mutex, NULL);
-    pthread_mutex_init(&pdp_cache_mutex, NULL);
-
-    // init symbol hash
-    memset(pdp_symhash, 0, HASHSIZE * sizeof(t_pdp_symbol *));
-
-    // create conversion lists
-    cached_conversion_list = pdp_list_new(0);
-    conversion_list = pdp_list_new(0);
-    max_cache_size = INIT_MAX_CACHE_SIZE;
-
-
-
-
-}
diff --git a/system/kernel/pdp_type.c_old b/system/kernel/pdp_type.c_old
deleted file mode 100644
index 4e42d53..0000000
--- a/system/kernel/pdp_type.c_old
+++ /dev/null
@@ -1,542 +0,0 @@
-/*
- *   Pure Data Packet system implementation. : code for handling different packet types
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-/* this file contains type handling routines 
-   note: pd symbols are used for type identification
-         for porting to other hosts, i suggest reimplementing t_pdp_symbol */
-
-// debug
-
-#include <fnmatch.h>
-#include <stdarg.h>
-#include <string.h>
-#include <pthread.h>
-#include "pdp.h"
-
-/*
-
-
-
-*/
-
-
-#define D if (0)
-
-
-static t_pdp_conversion *conversion_list;
-
-#define CACHE_SIZE 32
-static t_pdp_conversion *cached_conversion_list_start;
-static t_pdp_conversion cached_conversion_array[CACHE_SIZE];
-
-/* mutex */
-static pthread_mutex_t pdp_hash_mutex;
-static pthread_mutex_t pdp_conversion_mutex;
-static pthread_mutex_t pdp_cache_mutex;
-
-#define HASHSIZE 1024
-static t_pdp_symbol *pdp_symhash[HASHSIZE];
-
-
-/* shamelessly copied from pd src and made thread safe */
-t_pdp_symbol *_pdp_dogensym(char *s, t_pdp_symbol *oldsym)
-{
-    t_pdp_symbol **sym1, *sym2;
-    unsigned int hash1 = 0,  hash2 = 0;
-    int length = 0;
-    char *s2 = s;
-    while (*s2)
-    {
-        hash1 += *s2;
-        hash2 += hash1;
-        length++;
-        s2++;
-    }
-    sym1 = pdp_symhash + (hash2 & (HASHSIZE-1));
-
-    /* lock hash */
-    pthread_mutex_lock(&pdp_hash_mutex);
-
-    while (sym2 = *sym1)
-    {
-        if (!strcmp(sym2->s_name, s)) goto gotit;
-        sym1 = &sym2->s_next;
-    }
-    if (oldsym) sym2 = oldsym;
-    else
-    {
-        sym2 = (t_pdp_symbol *)pdp_alloc(sizeof(*sym2));
-        sym2->s_name = pdp_alloc(length+1);
-	_pdp_symbol_clear_namespaces(sym2);
-        sym2->s_next = 0;
-        strcpy(sym2->s_name, s);
-    }
-    *sym1 = sym2;
-
- gotit:
-
-    /* unlock hash */
-    pthread_mutex_unlock(&pdp_hash_mutex);
-    return (sym2);
-}
-
-t_pdp_symbol *pdp_gensym(char *s)
-{
-    return(_pdp_dogensym(s, 0));
-}
-
-/* convert a type to a list */
-t_pdp_list *pdp_type_to_list(t_pdp_symbol *type)
-{
-    char *c = type->s_name;
-    char *lastname = c;
-    char tmp[100];
-    int n = 0;
-    t_pdp_list *l = pdp_list_new(0);
-
-    while(*c){
-	if (*c == '/'){
-	    strncpy(tmp, lastname, n);
-	    tmp[n] = 0;
-	    pdp_list_add_back(l, a_symbol, (t_pdp_word)pdp_gensym(tmp));
-	    c++;
-	    lastname = c;
-	    n = 0;
-	}
-	else{
-	    c++;
-	    n++;
-	}
-    }
-    pdp_list_add_back(l, a_symbol, (t_pdp_word)pdp_gensym(lastname));
-
-    return l;
-}
-
-
-/* get the description symbol. this includes some compat transition stuff with a warning */
-t_pdp_symbol *pdp_packet_get_description(int packet)
-{
-    t_pdp *header = pdp_packet_header(packet);
-
-    if (!header) return pdp_gensym("invalid");
-    else if (!header->desc){
-	/* if description is not defined, try to reconstruct it (for backwards compat) */
-	if (header->type == PDP_IMAGE){
-	    post("FIXME: pdp_type_get_description: packet %d has no description. using workaround.", packet);
-	    return pdp_packet_image_get_description(packet);
-	}
-	else 
-	    return pdp_gensym("unknown");
-    }
-    else return header->desc;
-}
-
-
-
-/* this runs a conversion program */
-int _pdp_type_run_conversion_program(t_pdp_conversion_program *program,
-	 			    int packet, t_pdp_symbol *dest_template)
-{
-    /* run a conversion program:
-       treat the source packet as readonly, and cleanup intermediates, such
-       that the net result is the production of a new packet, with the
-       source packet intact. */
-
-    int p, tmp;
-
-    D post("DEBUG: _pdp_type_run_conversion_program: program = %x", program); 
-
-    // run the first line of the program
-    D post("DEBUG: _pdp_type_run_conversion_program: method = %x", *program);
-    p = (*program->method)(packet, dest_template);
-    D post("DEBUG: _pdp_type_run_conversion_program: packet returned = %d, type = %s", p, pdp_packet_get_description(p)->s_name);
-
-    // run the remaining lines + cleanup intermediates
-    for (program = program->next; program ; program = program->next){
-	D post("DEBUG: _pdp_type_run_conversion_program: next method ptr = %x", *program->method);
-	tmp = (*program->method)(p, dest_template);
-	pdp_packet_mark_unused(p);
-	p = tmp;
-    }
-    return p;
-}
-
-
-/* find a conversion program */
-t_pdp_conversion_program *
-_pdp_type_find_conversion_program(t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern)
-{
-    t_pdp_conversion *c;
-    t_pdp_conversion_program *retval = 0;
-
-    /* lock conversion list */
-    pthread_mutex_lock(&pdp_conversion_mutex);
-
-    for (c = conversion_list; c; c=c->next){
-	/* can be a wildcard match */
-	if (pdp_type_description_match(src_pattern, c->src_pattern) &&
-	    pdp_type_description_match(dst_pattern, c->dst_pattern)) {
-	    /* found a program */
-	    D post("DEBUG: _pdp_type_find_conversion_program: found: %s -> %s", c->src_pattern->s_name, c->dst_pattern->s_name);
-	    retval = c->program;
-	    goto gotit;
-	}
-    }
-
-    /* no conversion program was found */
-    retval = 0;
- gotit:
-
-    /* lock conversion list */
-    pthread_mutex_unlock(&pdp_conversion_mutex);
-    return retval;
-}
-
-/* find a cached conversion program */
-t_pdp_conversion_program *
-_pdp_type_find_cached_conversion_program(t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern)
-{
-    t_pdp_conversion *c;
-    t_pdp_conversion_program *retval = 0;
-
-    /* lock cached list */
-    pthread_mutex_lock(&pdp_cache_mutex);
-
-    for (c = cached_conversion_list_start; c; c=c->next){
-	/* must be exact match */
-	if ((src_pattern == c->src_pattern) &&
-	    (dst_pattern == c->dst_pattern)) {
-	    /* found a program */
-	    D post("DEBUG: _pdp_type_find_cached_conversion_program: found: %s -> %s", c->src_pattern->s_name, c->dst_pattern->s_name);
-	    retval = c->program;
-	    goto gotit;
-	}
-    }
-
-    retval = 0;
-
- gotit:
-
-    /* un lock cached list */
-    pthread_mutex_unlock(&pdp_cache_mutex);
-
-    /* no conversion program was found */
-    return retval;
-}
-
-
-/* conversion program manipulations */
-void pdp_conversion_program_free(t_pdp_conversion_program *program)
-{
-    t_pdp_conversion_program *p = 0;
-    while (program) {
-	p = program;
-	program = program->next;
-	pdp_dealloc (p);
-    }
-}
-
-/* debug print */
-void _pdp_conversion_program_print(t_pdp_conversion_program *program)
-{
-    D post("DEBUG: conversion program: %x", program);
-    while(program){
-	D post("DEBUG: method: %x", program->method);
-	program = program->next;
-    }
-}
-
-t_pdp_conversion_program *pdp_conversion_program_new(t_pdp_conversion_method method, ...)
-{
-    t_pdp_conversion_program head;
-    t_pdp_conversion_program *p = &head;
-    t_pdp_conversion_method m = method;
-    va_list ap;
-
-    D post("DEBUG: pdp_conversion_program_new:BEGIN");
-
-    p = p->next = (t_pdp_conversion_program *)pdp_alloc(sizeof(*p));
-    p->method = m;
-    va_start(ap, method);
-    while (m = va_arg(ap, t_pdp_conversion_method)){
-	p = p->next = (t_pdp_conversion_program *)pdp_alloc(sizeof(*p));
-	p->method = m;
-    }
-    p->next = 0; // terminate list
-    va_end(ap);
-
-    D post("DEBUG: pdp_conversion_program_new:END");
-    D _pdp_conversion_program_print(head.next);
-
-    return head.next;
-}
-
-t_pdp_conversion_program *pdp_conversion_program_copy(t_pdp_conversion_program *program)
-{
-    t_pdp_conversion_program head;
-    t_pdp_conversion_program *p = &head;
-
-    for(;program; program=program->next){
-	p = p->next = (t_pdp_conversion_program *)pdp_alloc(sizeof(*p));
-	p->method = program->method;
-    }
-    p->next = 0;
-    return head.next;
-}
-
-void pdp_conversion_program_add(t_pdp_conversion_program *program, t_pdp_conversion_program *tail)
-{ 
-    t_pdp_conversion_program *p = program;
-
-    //D post("DEBUG: pdp_conversion_program_add:BEGIN");
-
-
-    while (p->next) p = p->next;
-    p->next = pdp_conversion_program_copy(tail);
-
-    //D post("DEBUG: pdp_conversion_program_add:END");
-    
-}
-
-/* conversion registration */
-void pdp_type_register_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program)
-{
-    t_pdp_conversion head;
-    t_pdp_conversion *c = &head;
-
-    /* lock conversion list */
-    pthread_mutex_lock(&pdp_conversion_mutex);
-
-    head.next = conversion_list;
-
-    while (c->next) c=c->next; // add a new one to the end
-    c = c->next = (t_pdp_conversion *)pdp_alloc(sizeof(*c));
-    c->src_pattern = src_pattern;
-    c->dst_pattern = dst_pattern;
-    c->program = program;
-    c->next = 0;
-    
-    conversion_list = head.next;
-
-    /* unlock conversion list */
-    pthread_mutex_unlock(&pdp_conversion_mutex);
-    
-}
-
-/* register a cached conversion */
-void pdp_type_register_cached_conversion (t_pdp_symbol *src_pattern, t_pdp_symbol *dst_pattern, t_pdp_conversion_program *program)
-{
-
-    t_pdp_conversion *save, *c, *c2;
-
-    /* unlock cahed conversion list */
-    pthread_mutex_lock(&pdp_cache_mutex);
-
-    c2 = save = cached_conversion_list_start;
-    while (c2->next->next) c2 = c2->next;
-    c = c2->next;
-    c2->next = 0;
-    if (c->program) pdp_conversion_program_free(c->program);
-    c->src_pattern = src_pattern;
-    c->dst_pattern = dst_pattern;
-    c->program = program;
-    c->next = save;
-    cached_conversion_list_start = c;
-
-    /* unlock cached conversion list */
-    pthread_mutex_unlock(&pdp_cache_mutex);
-}
-
-/* convert a given packet to a certain type (template) */
-int _pdp_packet_convert(int packet, t_pdp_symbol *dest_template)
-{
-    t_pdp_symbol *type = pdp_packet_get_description(packet);
-    t_pdp_symbol *tmp_type = 0;
-    int tmp_packet = -1;
-
-    t_pdp_conversion_program *program = 0;
-    t_pdp_conversion_program *program_last = 0;
-    t_pdp_conversion_program *program_tail = 0;
-
-    /* check if there is a program in the cached list, if so run it */
-    if (program = _pdp_type_find_cached_conversion_program(type, dest_template))
-	return _pdp_type_run_conversion_program(program, packet, dest_template);
-
-    /* if it is not cached, iteratively convert 
-       and save program on top of cache list if a conversion path (program) was found */
-
-    // run first conversion that matches
-    program = pdp_conversion_program_copy(_pdp_type_find_conversion_program(type, dest_template));
-    program_last = program;
-    if (!program){
-	D post("DEBUG: pdp_type_convert: (1) can't convert %s to %s", type->s_name, dest_template->s_name);
-	return -1;
-    }
-    tmp_packet = _pdp_type_run_conversion_program(program, packet, dest_template);
-    tmp_type = pdp_packet_get_description(tmp_packet);
-
-    // run more conversions if necessary, deleting intermediate packets
-    while (!pdp_type_description_match(tmp_type, dest_template)){
-	int new_packet;
-	program_tail = _pdp_type_find_conversion_program(tmp_type, dest_template);
-	if (!program_tail){
-	    D post("DEBUG: pdp_type_convert: (2) can't convert %s to %s", tmp_type->s_name, dest_template->s_name);
-	    pdp_packet_mark_unused(tmp_packet);
-	    pdp_conversion_program_free(program);
-	    return -1;
-	}
-	if (program_last == program_tail){
-	    post("ERROR: pdp_packet_convert: conversion loop detected");
-	}
-	program_last = program_tail;
-
-	pdp_conversion_program_add(program, program_tail);
-	new_packet = _pdp_type_run_conversion_program(program_tail, tmp_packet, dest_template);
-	pdp_packet_mark_unused(tmp_packet);
-	tmp_packet = new_packet;
-	tmp_type = pdp_packet_get_description(tmp_packet);
-    }
-
-    // save the conversion program
-    pdp_type_register_cached_conversion(type, dest_template, program);
-
-    // return resulting packet
-    return tmp_packet;
-	
-}
-
-/* convert or copy ro */
-int pdp_packet_convert_ro(int packet, t_pdp_symbol *dest_template)
-{
-    t_pdp_symbol *type = pdp_packet_get_description(packet);
-
-    /* if it is compatible, return a ro copy */
-    if (pdp_type_description_match(type, dest_template)) return pdp_packet_copy_ro(packet);
-
-    /* if not, convert to a new type */
-    else return _pdp_packet_convert(packet, dest_template);
-}
-
-/* convert or copy rw */
-int pdp_packet_convert_rw(int packet, t_pdp_symbol *dest_template)
-{
-    t_pdp_symbol *type = pdp_packet_get_description(packet);
-
-    /* if it is compatible, just return a rw copy */
-    if (pdp_type_description_match(type, dest_template)) return pdp_packet_copy_rw(packet);
-
-    /* if not, convert to a new type */
-    else return _pdp_packet_convert(packet, dest_template);
-}
-
-
-static void _setup_type_cache(t_pdp_symbol *s)
-{
-    t_pdp_list *l = pdp_type_to_list(s); 
-    pthread_mutex_lock(&pdp_hash_mutex); //lock to prevent re-entry
-    if (!s->s_type){
-	s->s_type = l;
-	l = 0;
-    }
-    pthread_mutex_unlock(&pdp_hash_mutex);
-    if (l) pdp_list_free(l);
-}
-
-/* check if a type description fits a template
-   this function is symmetric */
-int pdp_type_description_match(t_pdp_symbol *description, t_pdp_symbol *pattern)
-{
-
-
-#if 1
-    t_pdp_atom *ad, *ap;
-    t_pdp_symbol *wildcard = pdp_gensym("*");
-
-    /* same type -> match */
-    if (description == pattern) return 1;
-
-    /* use the description list stored in the symbol for comparison */
-    if (!(description->s_type)) _setup_type_cache(description);
-    if (!(pattern->s_type)) _setup_type_cache(pattern);
-
-    /* check size */
-    if (description->s_type->elements != pattern->s_type->elements) return 0;
-
-    /* compare symbols of type list */
-    for(ad=description->s_type->first, ap=pattern->s_type->first; ad; ad=ad->next, ap=ap->next){
-	if (ad->w.w_symbol == wildcard) continue;
-	if (ap->w.w_symbol == wildcard) continue;
-	if (ad->w.w_symbol != ap->w.w_symbol) return 0; /* difference and not a wildcard */
-    }
-
-    /* type templates match */
-    return 1;
-
-
-#else
-    int retval = 0;
-    if (description == pattern) retval = 1;
-    //else retval = (!fnmatch(pattern->s_name, description->s_name, FNM_FILE_NAME));
-
-    //hack: make a symmetric match symmetric by calling fnmatch a second time with reversed attributes
-    else retval = ((!fnmatch(pattern->s_name, description->s_name, FNM_FILE_NAME))
-		   ||(!fnmatch(description->s_name, pattern->s_name, FNM_FILE_NAME)));
-
-
-    D post("DEBUG: testing match between %s and %s: %s", description->s_name, pattern->s_name, retval ? "match" : "no match");
-
-    return retval;
-#endif
-}
-
-
-
-
-
-/* setup method */
-void pdp_type_setup(void)
-{
-    int i;
-
-    // create mutexes
-    pthread_mutex_init(&pdp_hash_mutex, NULL);
-    pthread_mutex_init(&pdp_conversion_mutex, NULL);
-    pthread_mutex_init(&pdp_cache_mutex, NULL);
-
-    // init hash
-    memset(pdp_symhash, 0, HASHSIZE * sizeof(t_pdp_symbol *));
-
-    // init conversion lists
-    conversion_list = 0;
-    for(i=0; i<CACHE_SIZE; i++){
-	t_pdp_conversion *c = cached_conversion_array + i;
-	c->src_pattern = 0;
-	c->dst_pattern = 0;
-	c->program = 0;
-	c->next = c + 1;
-    }
-    cached_conversion_list_start = cached_conversion_array;
-    cached_conversion_array[CACHE_SIZE-1].next = 0;
-
-
-
-}
diff --git a/system/kernel/pdp_ut.c b/system/kernel/pdp_ut.c
deleted file mode 100644
index dadc493..0000000
--- a/system/kernel/pdp_ut.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- *   Pure Data Packet - Utility toolkit objects.
- *   Copyright (c) by Tom Schouten <pdp@zzz.kotnet.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-/* This file contains some small utility pd objects that make working with 
-   pdp objects a lot easier. Mainly as glue to be used in the abstractions 
-   in the distro. */
-
-
-#include "pdp.h"
-#include <math.h>
-
-/* this object does an add, scale, clip operation */
-
-t_class *pdp_ut_addscaleclip_class;
-
-typedef struct pdp_ut_addscaleclip_struct
-{
-    t_object x_obj;
-    t_outlet *x_outlet0;
-    t_float x_min;
-    t_float x_max;
-    t_float x_offset;
-    t_float x_scale;
-} t_pdp_ut_addscaleclip;
-
-
-static void pdp_ut_addscaleclip_float(t_pdp_ut_addscaleclip *x, t_floatarg f)
-{
-    f += x->x_offset;
-    f *= x->x_scale;
-    f = (f < x->x_min) ? x->x_min : f;
-    f = (f > x->x_max) ? x->x_max : f;
-    outlet_float(x->x_outlet0, f);
-}
-
-static void pdp_ut_addscaleclip_free(t_pdp_ut_addscaleclip *x){}
-
-void *pdp_ut_addscaleclip_new(t_floatarg offset, t_floatarg scale, t_floatarg min, t_floatarg max)
-{
-    t_pdp_ut_addscaleclip *x = (t_pdp_ut_addscaleclip *)pd_new(pdp_ut_addscaleclip_class);
-    x->x_outlet0 = outlet_new(&x->x_obj, &s_float); 
-    x->x_offset = offset;
-    x->x_scale = scale;
-    x->x_min = min;
-    x->x_max = max;
-    return (void *)x;
-}
-
-void pdp_ut_addscaleclip_setup(void)
-{
-    pdp_ut_addscaleclip_class = class_new(gensym("pdp_ut_addscaleclip"), (t_newmethod)pdp_ut_addscaleclip_new,
-			      (t_method)pdp_ut_addscaleclip_free, sizeof(t_pdp_ut_addscaleclip), 0, 
-					 A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_NULL);
-    class_addfloat(pdp_ut_addscaleclip_class,  pdp_ut_addscaleclip_float);
-}
-
-
-/* pdp_ut_logmap does a logarithmic parameter mapping [0->1] x -> min(max/min)^x max an add, scale, clip operation */
-/* pdp_ut_logmap_comp does x -> min(max/min)^(1-x) */
-/* pdp_ut_linmap dos x -> min + (max - min * x */
-
-t_class *pdp_ut_linmap_class;
-t_class *pdp_ut_logmap_class;
-t_class *pdp_ut_logmap_comp_class;
-
-typedef struct pdp_ut_map_struct
-{
-    t_object x_obj;
-    t_outlet *x_outlet0;
-    t_float x_min;
-    t_float x_max;
-} t_pdp_ut_map;
-
-
-static void pdp_ut_logmap_float(t_pdp_ut_map *x, t_floatarg f)
-{
-    f = (f < 0.0f) ? 0.0f : f;
-    f = (f > 1.0f) ? 1.0f : f;
-
-    f = x->x_min * pow((x->x_max / x->x_min), f);
-
-    outlet_float(x->x_outlet0, f);
-}
-
-static void pdp_ut_linmap_float(t_pdp_ut_map *x, t_floatarg f)
-{
-    f = (f < 0.0f) ? 0.0f : f;
-    f = (f > 1.0f) ? 1.0f : f;
-
-    f = x->x_min + ((x->x_max - x->x_min) * f);
-
-    outlet_float(x->x_outlet0, f);
-}
-
-static void pdp_ut_logmap_comp_float(t_pdp_ut_map *x, t_floatarg f)
-{
-    f = (f < 0.0f) ? 0.0f : f;
-    f = (f > 1.0f) ? 1.0f : f;
-
-    f = x->x_min * pow((x->x_max / x->x_min), (1.0f - f));
-
-    outlet_float(x->x_outlet0, f);
-}
-
-static void pdp_ut_map_free(t_pdp_ut_map *x){}
-
-
-void pdp_ut_map_init(t_pdp_ut_map *x, t_floatarg min, t_floatarg max)
-{
-    x->x_outlet0 = outlet_new(&x->x_obj, &s_float); 
-    x->x_min = min;
-    x->x_max = max;
-}
-
-void *pdp_ut_logmap_new(t_floatarg min, t_floatarg max)
-{
-    t_pdp_ut_map *x = (t_pdp_ut_map *)pd_new(pdp_ut_logmap_class);
-    pdp_ut_map_init(x, min, max);
-    return (void *)x;
-}
-
-void *pdp_ut_linmap_new(t_floatarg min, t_floatarg max)
-{
-    t_pdp_ut_map *x = (t_pdp_ut_map *)pd_new(pdp_ut_linmap_class);
-    pdp_ut_map_init(x, min, max);
-    return (void *)x;
-}
-
-void *pdp_ut_logmap_comp_new(t_floatarg min, t_floatarg max)
-{
-    t_pdp_ut_map *x = (t_pdp_ut_map *)pd_new(pdp_ut_logmap_comp_class);
-    pdp_ut_map_init(x, min, max);
-    return (void *)x;
-}
-
-void pdp_ut_logmap_setup(void)
-{
-    pdp_ut_logmap_class = class_new(gensym("pdp_ut_logmap"), (t_newmethod)pdp_ut_logmap_new,
-			      (t_method)pdp_ut_map_free, sizeof(t_pdp_ut_map), 0, 
-					 A_FLOAT, A_FLOAT, A_NULL);
-    class_addfloat(pdp_ut_logmap_class,  pdp_ut_logmap_float);
-}
-
-void pdp_ut_logmap_comp_setup(void)
-{
-    pdp_ut_logmap_comp_class = class_new(gensym("pdp_ut_logmap_comp"), (t_newmethod)pdp_ut_logmap_comp_new,
-			      (t_method)pdp_ut_map_free, sizeof(t_pdp_ut_map), 0, 
-					 A_FLOAT, A_FLOAT, A_NULL);
-    class_addfloat(pdp_ut_logmap_comp_class,  pdp_ut_logmap_comp_float);
-}
-
-void pdp_ut_linmap_setup(void)
-{
-    pdp_ut_linmap_class = class_new(gensym("pdp_ut_linmap"), (t_newmethod)pdp_ut_linmap_new,
-			      (t_method)pdp_ut_map_free, sizeof(t_pdp_ut_map), 0, 
-					 A_FLOAT, A_FLOAT, A_NULL);
-    class_addfloat(pdp_ut_linmap_class,  pdp_ut_linmap_float);
-}
-
-
-
-t_class *pdp_ut_rgb2ycrcb_class;
-
-typedef struct pdp_ut_rgb2ycrcb
-{
-    t_object x_obj;
-    t_outlet *x_outlet_luma;
-    t_outlet *x_outlet_chroma_red;
-    t_outlet *x_outlet_chroma_blue;
-
-    t_float x_red, x_green, x_blue;
-
-} t_pdp_ut_rgb2ycrcb;
-
-
-static void pdp_ut_rgb2ycrcb_bang  (t_pdp_ut_rgb2ycrcb* x)
-{
-
-    float luma = 0.299f * x->x_red + 0.587f * x->x_green + 0.114f * x->x_blue;
-    float chroma_red  = (x->x_red - luma) * 0.713f;
-    float chroma_blue = (x->x_blue - luma) * 0.565f;
-
-    outlet_float(x->x_outlet_chroma_blue, chroma_blue);
-    outlet_float(x->x_outlet_chroma_red, chroma_red);
-    outlet_float(x->x_outlet_luma, luma);
-
-}
-
-
-static void pdp_ut_rgb2ycrcb_red   (t_pdp_ut_rgb2ycrcb* x, t_floatarg f)   {x->x_red = f;   pdp_ut_rgb2ycrcb_bang(x);}
-static void pdp_ut_rgb2ycrcb_green (t_pdp_ut_rgb2ycrcb* x, t_floatarg f)   {x->x_green = f; pdp_ut_rgb2ycrcb_bang(x);}
-static void pdp_ut_rgb2ycrcb_blue  (t_pdp_ut_rgb2ycrcb* x, t_floatarg f)   {x->x_blue = f;  pdp_ut_rgb2ycrcb_bang(x);}
-
-
-
-static void pdp_ut_rgb2ycrcb_free  (t_pdp_ut_rgb2ycrcb* x)  {}
-static void* pdp_ut_rgb2ycrcb_new(void)
-{
-    t_pdp_ut_rgb2ycrcb *x = (t_pdp_ut_rgb2ycrcb *)pd_new(pdp_ut_rgb2ycrcb_class);
-
-
-    inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("green"));
-    inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("blue"));
-
-    x->x_outlet_luma        = outlet_new(&x->x_obj, &s_float); 
-    x->x_outlet_chroma_red  = outlet_new(&x->x_obj, &s_float); 
-    x->x_outlet_chroma_blue = outlet_new(&x->x_obj, &s_float); 
-
-    x->x_red = 0.0f;
-    x->x_green = 0.0f;
-    x->x_blue = 0.0f;
-
-
-    return (void *)x;
-}
-
-void pdp_ut_rgb2ycrcb_setup(void)
-{
-    pdp_ut_rgb2ycrcb_class = class_new(gensym("pdp_ut_rgb2ycrcb"), (t_newmethod)pdp_ut_rgb2ycrcb_new,
-			      (t_method)pdp_ut_rgb2ycrcb_free, sizeof(t_pdp_ut_rgb2ycrcb), 0, A_NULL);
-    class_addfloat(pdp_ut_rgb2ycrcb_class,  pdp_ut_rgb2ycrcb_red);
-    class_addmethod(pdp_ut_rgb2ycrcb_class,  (t_method)pdp_ut_rgb2ycrcb_green, gensym("green"), A_FLOAT, A_NULL);
-    class_addmethod(pdp_ut_rgb2ycrcb_class,  (t_method)pdp_ut_rgb2ycrcb_blue, gensym("blue"), A_FLOAT, A_NULL);
-}
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-void pdp_ut_setup(void)
-{
-    pdp_ut_addscaleclip_setup();
-    pdp_ut_logmap_setup();
-    pdp_ut_logmap_comp_setup();
-    pdp_ut_linmap_setup();
-    pdp_ut_rgb2ycrcb_setup();
-}
-
-
-#ifdef __cplusplus
-}
-#endif